sig
module Std :
sig
module Monoid :
sig
module type Base =
sig
type t
val zero : Monads.Std.Monoid.Base.t
val plus :
Monads.Std.Monoid.Base.t ->
Monads.Std.Monoid.Base.t -> Monads.Std.Monoid.Base.t
end
module type S =
sig
type t
val zero : t
val plus : t -> t -> t
val concat : t list -> t
val ( @@ ) : t -> t -> t
end
module Make :
functor (M : Base) ->
sig
val zero : M.t
val plus : M.t -> M.t -> M.t
val concat : M.t list -> M.t
val ( @@ ) : M.t -> M.t -> M.t
end
module Unit :
sig
type t = unit
val zero : t
val plus : t -> t -> t
val concat : t list -> t
val ( @@ ) : t -> t -> t
end
module TList :
functor (T : Core_kernel.Std.T) -> sig type t = T.t list end
module Stack :
sig
module Make :
functor (T : Core_kernel.Std.T) ->
sig
val zero : TList(T).t
val plus : TList(T).t -> TList(T).t -> TList(T).t
val concat : TList(T).t list -> TList(T).t
val ( @@ ) : TList(T).t -> TList(T).t -> TList(T).t
end
end
module List :
sig
module Make :
functor (T : Core_kernel.Std.T) ->
sig
val zero : TList(T).t
val plus : TList(T).t -> TList(T).t -> TList(T).t
val concat : TList(T).t list -> TList(T).t
val ( @@ ) : TList(T).t -> TList(T).t -> TList(T).t
end
end
module String :
sig
type t = string
val zero : t
val plus : t -> t -> t
val concat : t list -> t
val ( @@ ) : t -> t -> t
end
module Set :
sig
module Make :
functor (S : Core_kernel.Std.Set.S) ->
sig
val zero : S.t
val plus : S.t -> S.t -> S.t
val concat : S.t list -> S.t
val ( @@ ) : S.t -> S.t -> S.t
end
end
module Int :
sig
type t = int
val zero : t
val plus : t -> t -> t
val concat : t list -> t
val ( @@ ) : t -> t -> t
module Sum :
sig
type t = int
val zero : t
val plus : t -> t -> t
val concat : t list -> t
val ( @@ ) : t -> t -> t
end
module Product :
sig
type t = Sum.t
val zero : t
val plus : t -> t -> t
val concat : t list -> t
val ( @@ ) : t -> t -> t
end
end
module Float :
sig
type t = float
val zero : t
val plus : t -> t -> t
val concat : t list -> t
val ( @@ ) : t -> t -> t
module Sum :
sig
type t = float
val zero : t
val plus : t -> t -> t
val concat : t list -> t
val ( @@ ) : t -> t -> t
end
module Product :
sig
type t = Sum.t
val zero : t
val plus : t -> t -> t
val concat : t list -> t
val ( @@ ) : t -> t -> t
end
end
end
module Monad :
sig
module Plus :
sig
module type S =
sig
type 'a t
val zero : unit -> 'a Monads.Std.Monad.Plus.S.t
val plus :
'a Monads.Std.Monad.Plus.S.t ->
'a Monads.Std.Monad.Plus.S.t ->
'a Monads.Std.Monad.Plus.S.t
end
module type S2 =
sig
type ('a, 'e) t
val zero : unit -> ('a, 'e) Monads.Std.Monad.Plus.S2.t
val plus :
('a, 'e) Monads.Std.Monad.Plus.S2.t ->
('a, 'e) Monads.Std.Monad.Plus.S2.t ->
('a, 'e) Monads.Std.Monad.Plus.S2.t
end
end
module Fail :
sig
module type S =
sig
type 'a error
type 'a t
val fail :
'b Monads.Std.Monad.Fail.S.error ->
'a Monads.Std.Monad.Fail.S.t
val catch :
'a Monads.Std.Monad.Fail.S.t ->
('b Monads.Std.Monad.Fail.S.error ->
'a Monads.Std.Monad.Fail.S.t) ->
'a Monads.Std.Monad.Fail.S.t
end
module type S2 =
sig
type 'a error
type ('a, 'e) t
val fail :
'e Monads.Std.Monad.Fail.S2.error ->
('a, 'e) Monads.Std.Monad.Fail.S2.t
val catch :
('a, 'e) Monads.Std.Monad.Fail.S2.t ->
('e Monads.Std.Monad.Fail.S2.error ->
('a, 'e) Monads.Std.Monad.Fail.S2.t) ->
('a, 'e) Monads.Std.Monad.Fail.S2.t
end
end
module Choice :
sig
module type Basic =
sig
type 'a t
val pure : 'a -> 'a Monads.Std.Monad.Choice.Basic.t
val zero : unit -> 'a Monads.Std.Monad.Choice.Basic.t
end
module type S =
sig
type 'a t
val pure : 'a -> 'a t
val zero : Monoid.Unit.t -> 'a t
val accept : 'a -> 'a Monads.Std.Monad.Choice.S.t
val reject : unit -> 'a Monads.Std.Monad.Choice.S.t
val guard : bool -> unit Monads.Std.Monad.Choice.S.t
val on :
bool ->
unit Monads.Std.Monad.Choice.S.t ->
unit Monads.Std.Monad.Choice.S.t
val unless :
bool ->
unit Monads.Std.Monad.Choice.S.t ->
unit Monads.Std.Monad.Choice.S.t
end
module type Basic2 =
sig
type ('a, 'e) t
val pure : 'a -> ('a, 'e) Monads.Std.Monad.Choice.Basic2.t
val zero :
unit -> ('a, 'e) Monads.Std.Monad.Choice.Basic2.t
end
module type S2 =
sig
type ('a, 'e) t
val pure : 'a -> ('a, 'e) t
val zero : Monoid.Unit.t -> ('a, 'e) t
val accept : 'a -> ('a, 'e) Monads.Std.Monad.Choice.S2.t
val reject : unit -> ('a, 'e) Monads.Std.Monad.Choice.S2.t
val guard : bool -> (unit, 'e) Monads.Std.Monad.Choice.S2.t
val on :
bool ->
(unit, 'e) Monads.Std.Monad.Choice.S2.t ->
(unit, 'e) Monads.Std.Monad.Choice.S2.t
val unless :
bool ->
(unit, 'e) Monads.Std.Monad.Choice.S2.t ->
(unit, 'e) Monads.Std.Monad.Choice.S2.t
end
module Make :
functor (M : Basic) ->
sig
val pure : 'a -> 'a M.t
val zero : Monoid.Unit.t -> 'a M.t
val accept : 'a -> 'a M.t
val reject : Monoid.Unit.t -> 'a M.t
val guard : bool -> Monoid.Unit.t M.t
val on : bool -> Monoid.Unit.t M.t -> Monoid.Unit.t M.t
val unless :
bool -> Monoid.Unit.t M.t -> Monoid.Unit.t M.t
end
module Make2 :
functor (M : Basic2) ->
sig
val pure : 'a -> ('a, 'e) M.t
val zero : Monoid.Unit.t -> ('a, 'e) M.t
val accept : 'a -> ('a, 'e) M.t
val reject : Monoid.Unit.t -> ('a, 'e) M.t
val guard : bool -> (Monoid.Unit.t, 'e) M.t
val on :
bool ->
(Monoid.Unit.t, 'e) M.t -> (Monoid.Unit.t, 'e) M.t
val unless :
bool ->
(Monoid.Unit.t, 'e) M.t -> (Monoid.Unit.t, 'e) M.t
end
end
module Trans :
sig
module type S =
sig
type 'a t
type 'a m
type 'a e
val lift :
'a Monads.Std.Monad.Trans.S.m ->
'a Monads.Std.Monad.Trans.S.t
val run :
'a Monads.Std.Monad.Trans.S.t ->
'a Monads.Std.Monad.Trans.S.e
end
module type S1 =
sig
type ('a, 'e) t
type 'a m
type ('a, 'e) e
val lift :
'a Monads.Std.Monad.Trans.S1.m ->
('a, 'e) Monads.Std.Monad.Trans.S1.t
val run :
('a, 'e) Monads.Std.Monad.Trans.S1.t ->
('a, 'e) Monads.Std.Monad.Trans.S1.e
end
module type S2 =
sig
type ('a, 'e) t
type ('a, 'e) m
type ('a, 'e) e
val lift :
('a, 'e) Monads.Std.Monad.Trans.S2.m ->
('a, 'e) Monads.Std.Monad.Trans.S2.t
val run :
('a, 'e) Monads.Std.Monad.Trans.S2.t ->
('a, 'e) Monads.Std.Monad.Trans.S2.e
end
end
module type Basic =
sig
type 'a t
val bind :
'a Monads.Std.Monad.Basic.t ->
('a -> 'b Monads.Std.Monad.Basic.t) ->
'b Monads.Std.Monad.Basic.t
val return : 'a -> 'a Monads.Std.Monad.Basic.t
val map :
[ `Custom of
'a Monads.Std.Monad.Basic.t ->
f:('a -> 'b) -> 'b Monads.Std.Monad.Basic.t
| `Define_using_bind ]
end
module type Basic2 =
sig
type ('a, 'e) t
val bind :
('a, 'e) Monads.Std.Monad.Basic2.t ->
('a -> ('b, 'e) Monads.Std.Monad.Basic2.t) ->
('b, 'e) Monads.Std.Monad.Basic2.t
val map :
[ `Custom of
('a, 'e) Monads.Std.Monad.Basic2.t ->
f:('a -> 'b) -> ('b, 'e) Monads.Std.Monad.Basic2.t
| `Define_using_bind ]
val return : 'a -> ('a, 'b) Monads.Std.Monad.Basic2.t
end
module Collection :
sig
module type Basic =
sig
type 'a t
val return : 'a -> 'a Monads.Std.Monad.Collection.Basic.t
val zero : Monoid.Unit.t -> 'a t
val plus : 'a t -> 'a t -> 'a t
end
module type Eager =
sig
type 'a t
val return : 'a -> 'a t
val zero : Monoid.Unit.t -> 'a t
val plus : 'a t -> 'a t -> 'a t
val fold : 'a t -> init:'s -> f:('s -> 'a -> 's) -> 's
end
module type Delay =
sig
type 'a t
val return : 'a -> 'a t
val zero : Monoid.Unit.t -> 'a t
val plus : 'a t -> 'a t -> 'a t
val fold :
'a t ->
init:'s ->
f:('s -> 'a -> ('s -> 'r) -> 'r) -> ('s -> 'r) -> 'r
end
module type S2 =
sig
type ('a, 'e) m
type 'a t
val all :
('a, 'e) Monads.Std.Monad.Collection.S2.m
Monads.Std.Monad.Collection.S2.t ->
('a Monads.Std.Monad.Collection.S2.t, 'e)
Monads.Std.Monad.Collection.S2.m
val all_ignore :
('a, 'e) Monads.Std.Monad.Collection.S2.m
Monads.Std.Monad.Collection.S2.t ->
(unit, 'e) Monads.Std.Monad.Collection.S2.m
val sequence :
(unit, 'e) Monads.Std.Monad.Collection.S2.m
Monads.Std.Monad.Collection.S2.t ->
(unit, 'e) Monads.Std.Monad.Collection.S2.m
val map :
'a Monads.Std.Monad.Collection.S2.t ->
f:('a -> ('b, 'e) Monads.Std.Monad.Collection.S2.m) ->
('b Monads.Std.Monad.Collection.S2.t, 'e)
Monads.Std.Monad.Collection.S2.m
val iter :
'a Monads.Std.Monad.Collection.S2.t ->
f:('a -> (unit, 'e) Monads.Std.Monad.Collection.S2.m) ->
(unit, 'e) Monads.Std.Monad.Collection.S2.m
val fold :
'a Monads.Std.Monad.Collection.S2.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) Monads.Std.Monad.Collection.S2.m) ->
('b, 'e) Monads.Std.Monad.Collection.S2.m
val fold_left :
'a Monads.Std.Monad.Collection.S2.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) Monads.Std.Monad.Collection.S2.m) ->
('b, 'e) Monads.Std.Monad.Collection.S2.m
val fold_right :
'a Monads.Std.Monad.Collection.S2.t ->
f:('a -> 'b -> ('b, 'e) Monads.Std.Monad.Collection.S2.m) ->
init:'b -> ('b, 'e) Monads.Std.Monad.Collection.S2.m
val reduce :
'a Monads.Std.Monad.Collection.S2.t ->
f:('a -> 'a -> ('a, 'e) Monads.Std.Monad.Collection.S2.m) ->
('a option, 'e) Monads.Std.Monad.Collection.S2.m
val exists :
'a Monads.Std.Monad.Collection.S2.t ->
f:('a -> (bool, 'e) Monads.Std.Monad.Collection.S2.m) ->
(bool, 'e) Monads.Std.Monad.Collection.S2.m
val for_all :
'a Monads.Std.Monad.Collection.S2.t ->
f:('a -> (bool, 'e) Monads.Std.Monad.Collection.S2.m) ->
(bool, 'e) Monads.Std.Monad.Collection.S2.m
val count :
'a Monads.Std.Monad.Collection.S2.t ->
f:('a -> (bool, 'e) Monads.Std.Monad.Collection.S2.m) ->
(int, 'e) Monads.Std.Monad.Collection.S2.m
val map_reduce :
(module Monads.Std.Monoid.S with type t = 'a) ->
'b Monads.Std.Monad.Collection.S2.t ->
f:('b -> ('a, 'e) Monads.Std.Monad.Collection.S2.m) ->
('a, 'e) Monads.Std.Monad.Collection.S2.m
val find :
'a Monads.Std.Monad.Collection.S2.t ->
f:('a -> (bool, 'e) Monads.Std.Monad.Collection.S2.m) ->
('a option, 'e) Monads.Std.Monad.Collection.S2.m
val find_map :
'a Monads.Std.Monad.Collection.S2.t ->
f:('a -> ('b option, 'e) Monads.Std.Monad.Collection.S2.m) ->
('b option, 'e) Monads.Std.Monad.Collection.S2.m
val filter :
'a Monads.Std.Monad.Collection.S2.t ->
f:('a -> (bool, 'e) Monads.Std.Monad.Collection.S2.m) ->
('a Monads.Std.Monad.Collection.S2.t, 'e)
Monads.Std.Monad.Collection.S2.m
val filter_map :
'a Monads.Std.Monad.Collection.S2.t ->
f:('a -> ('b option, 'e) Monads.Std.Monad.Collection.S2.m) ->
('b Monads.Std.Monad.Collection.S2.t, 'e)
Monads.Std.Monad.Collection.S2.m
end
module type S =
sig
type 'a m
type 'a t
val all :
'a Monads.Std.Monad.Collection.S.m
Monads.Std.Monad.Collection.S.t ->
'a Monads.Std.Monad.Collection.S.t
Monads.Std.Monad.Collection.S.m
val all_ignore :
'a Monads.Std.Monad.Collection.S.m
Monads.Std.Monad.Collection.S.t ->
unit Monads.Std.Monad.Collection.S.m
val sequence :
unit Monads.Std.Monad.Collection.S.m
Monads.Std.Monad.Collection.S.t ->
unit Monads.Std.Monad.Collection.S.m
val map :
'a Monads.Std.Monad.Collection.S.t ->
f:('a -> 'b Monads.Std.Monad.Collection.S.m) ->
'b Monads.Std.Monad.Collection.S.t
Monads.Std.Monad.Collection.S.m
val iter :
'a Monads.Std.Monad.Collection.S.t ->
f:('a -> unit Monads.Std.Monad.Collection.S.m) ->
unit Monads.Std.Monad.Collection.S.m
val fold :
'a Monads.Std.Monad.Collection.S.t ->
init:'b ->
f:('b -> 'a -> 'b Monads.Std.Monad.Collection.S.m) ->
'b Monads.Std.Monad.Collection.S.m
val fold_left :
'a Monads.Std.Monad.Collection.S.t ->
init:'b ->
f:('b -> 'a -> 'b Monads.Std.Monad.Collection.S.m) ->
'b Monads.Std.Monad.Collection.S.m
val fold_right :
'a Monads.Std.Monad.Collection.S.t ->
f:('a -> 'b -> 'b Monads.Std.Monad.Collection.S.m) ->
init:'b -> 'b Monads.Std.Monad.Collection.S.m
val reduce :
'a Monads.Std.Monad.Collection.S.t ->
f:('a -> 'a -> 'a Monads.Std.Monad.Collection.S.m) ->
'a option Monads.Std.Monad.Collection.S.m
val exists :
'a Monads.Std.Monad.Collection.S.t ->
f:('a -> bool Monads.Std.Monad.Collection.S.m) ->
bool Monads.Std.Monad.Collection.S.m
val for_all :
'a Monads.Std.Monad.Collection.S.t ->
f:('a -> bool Monads.Std.Monad.Collection.S.m) ->
bool Monads.Std.Monad.Collection.S.m
val count :
'a Monads.Std.Monad.Collection.S.t ->
f:('a -> bool Monads.Std.Monad.Collection.S.m) ->
int Monads.Std.Monad.Collection.S.m
val map_reduce :
(module Monads.Std.Monoid.S with type t = 'a) ->
'b Monads.Std.Monad.Collection.S.t ->
f:('b -> 'a Monads.Std.Monad.Collection.S.m) ->
'a Monads.Std.Monad.Collection.S.m
val find :
'a Monads.Std.Monad.Collection.S.t ->
f:('a -> bool Monads.Std.Monad.Collection.S.m) ->
'a option Monads.Std.Monad.Collection.S.m
val find_map :
'a Monads.Std.Monad.Collection.S.t ->
f:('a -> 'b option Monads.Std.Monad.Collection.S.m) ->
'b option Monads.Std.Monad.Collection.S.m
val filter :
'a Monads.Std.Monad.Collection.S.t ->
f:('a -> bool Monads.Std.Monad.Collection.S.m) ->
'a Monads.Std.Monad.Collection.S.t
Monads.Std.Monad.Collection.S.m
val filter_map :
'a Monads.Std.Monad.Collection.S.t ->
f:('a -> 'b option Monads.Std.Monad.Collection.S.m) ->
'b Monads.Std.Monad.Collection.S.t
Monads.Std.Monad.Collection.S.m
end
end
module Syntax :
sig
module type S =
sig
type 'a t
val ( >>= ) :
'a Monads.Std.Monad.Syntax.S.t ->
('a -> 'b Monads.Std.Monad.Syntax.S.t) ->
'b Monads.Std.Monad.Syntax.S.t
val ( >>| ) :
'a Monads.Std.Monad.Syntax.S.t ->
('a -> 'b) -> 'b Monads.Std.Monad.Syntax.S.t
val ( >=> ) :
('a -> 'b Monads.Std.Monad.Syntax.S.t) ->
('b -> 'c Monads.Std.Monad.Syntax.S.t) ->
'a -> 'c Monads.Std.Monad.Syntax.S.t
val ( !! ) : 'a -> 'a Monads.Std.Monad.Syntax.S.t
val ( !$ ) :
('a -> 'b) ->
'a Monads.Std.Monad.Syntax.S.t ->
'b Monads.Std.Monad.Syntax.S.t
val ( !$$ ) :
('a -> 'b -> 'c) ->
'a Monads.Std.Monad.Syntax.S.t ->
'b Monads.Std.Monad.Syntax.S.t ->
'c Monads.Std.Monad.Syntax.S.t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a Monads.Std.Monad.Syntax.S.t ->
'b Monads.Std.Monad.Syntax.S.t ->
'c Monads.Std.Monad.Syntax.S.t ->
'd Monads.Std.Monad.Syntax.S.t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a Monads.Std.Monad.Syntax.S.t ->
'b Monads.Std.Monad.Syntax.S.t ->
'c Monads.Std.Monad.Syntax.S.t ->
'd Monads.Std.Monad.Syntax.S.t ->
'e Monads.Std.Monad.Syntax.S.t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a Monads.Std.Monad.Syntax.S.t ->
'b Monads.Std.Monad.Syntax.S.t ->
'c Monads.Std.Monad.Syntax.S.t ->
'd Monads.Std.Monad.Syntax.S.t ->
'e Monads.Std.Monad.Syntax.S.t ->
'f Monads.Std.Monad.Syntax.S.t
end
module type S2 =
sig
type ('a, 'e) t
val ( >>= ) :
('a, 'e) Monads.Std.Monad.Syntax.S2.t ->
('a -> ('b, 'e) Monads.Std.Monad.Syntax.S2.t) ->
('b, 'e) Monads.Std.Monad.Syntax.S2.t
val ( >>| ) :
('a, 'e) Monads.Std.Monad.Syntax.S2.t ->
('a -> 'b) -> ('b, 'e) Monads.Std.Monad.Syntax.S2.t
val ( >=> ) :
('a -> ('b, 'e) Monads.Std.Monad.Syntax.S2.t) ->
('b -> ('c, 'e) Monads.Std.Monad.Syntax.S2.t) ->
'a -> ('c, 'e) Monads.Std.Monad.Syntax.S2.t
val ( !! ) : 'a -> ('a, 'e) Monads.Std.Monad.Syntax.S2.t
val ( !$ ) :
('a -> 'b) ->
('a, 'e) Monads.Std.Monad.Syntax.S2.t ->
('b, 'e) Monads.Std.Monad.Syntax.S2.t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) Monads.Std.Monad.Syntax.S2.t ->
('b, 'e) Monads.Std.Monad.Syntax.S2.t ->
('c, 'e) Monads.Std.Monad.Syntax.S2.t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) Monads.Std.Monad.Syntax.S2.t ->
('b, 'e) Monads.Std.Monad.Syntax.S2.t ->
('c, 'e) Monads.Std.Monad.Syntax.S2.t ->
('d, 'e) Monads.Std.Monad.Syntax.S2.t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) Monads.Std.Monad.Syntax.S2.t ->
('b, 's) Monads.Std.Monad.Syntax.S2.t ->
('c, 's) Monads.Std.Monad.Syntax.S2.t ->
('d, 's) Monads.Std.Monad.Syntax.S2.t ->
('e, 's) Monads.Std.Monad.Syntax.S2.t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) Monads.Std.Monad.Syntax.S2.t ->
('b, 's) Monads.Std.Monad.Syntax.S2.t ->
('c, 's) Monads.Std.Monad.Syntax.S2.t ->
('d, 's) Monads.Std.Monad.Syntax.S2.t ->
('e, 's) Monads.Std.Monad.Syntax.S2.t ->
('f, 's) Monads.Std.Monad.Syntax.S2.t
end
end
module type S =
sig
type 'a t
val void : 'a Monads.Std.Monad.S.t -> unit Monads.Std.Monad.S.t
val sequence :
unit Monads.Std.Monad.S.t list -> unit Monads.Std.Monad.S.t
val forever :
'a Monads.Std.Monad.S.t -> 'b Monads.Std.Monad.S.t
module Fn :
sig
val id : 'a -> 'a Monads.Std.Monad.S.t
val ignore :
'a Monads.Std.Monad.S.t -> unit Monads.Std.Monad.S.t
val nothing : unit -> unit Monads.Std.Monad.S.t
val non :
('a -> bool Monads.Std.Monad.S.t) ->
'a -> bool Monads.Std.Monad.S.t
val apply_n_times :
n:int ->
('a -> 'a Monads.Std.Monad.S.t) ->
'a -> 'a Monads.Std.Monad.S.t
val compose :
('b -> 'c Monads.Std.Monad.S.t) ->
('a -> 'b Monads.Std.Monad.S.t) ->
'a -> 'c Monads.Std.Monad.S.t
end
module Pair :
sig
val fst :
('a * 'b) Monads.Std.Monad.S.t -> 'a Monads.Std.Monad.S.t
val snd :
('a * 'b) Monads.Std.Monad.S.t -> 'b Monads.Std.Monad.S.t
end
module Triple :
sig
val fst :
('a * 'b * 'c) Monads.Std.Monad.S.t ->
'a Monads.Std.Monad.S.t
val snd :
('a * 'b * 'c) Monads.Std.Monad.S.t ->
'b Monads.Std.Monad.S.t
val trd :
('a * 'b * 'c) Monads.Std.Monad.S.t ->
'c Monads.Std.Monad.S.t
end
module Lift :
sig
val nullary : 'a -> 'a Monads.Std.Monad.S.t
val unary :
('a -> 'b) ->
'a Monads.Std.Monad.S.t -> 'b Monads.Std.Monad.S.t
val binary :
('a -> 'b -> 'c) ->
'a Monads.Std.Monad.S.t ->
'b Monads.Std.Monad.S.t -> 'c Monads.Std.Monad.S.t
val ternary :
('a -> 'b -> 'c -> 'd) ->
'a Monads.Std.Monad.S.t ->
'b Monads.Std.Monad.S.t ->
'c Monads.Std.Monad.S.t -> 'd Monads.Std.Monad.S.t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a Monads.Std.Monad.S.t ->
'b Monads.Std.Monad.S.t ->
'c Monads.Std.Monad.S.t ->
'd Monads.Std.Monad.S.t -> 'e Monads.Std.Monad.S.t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a Monads.Std.Monad.S.t ->
'b Monads.Std.Monad.S.t ->
'c Monads.Std.Monad.S.t ->
'd Monads.Std.Monad.S.t ->
'e Monads.Std.Monad.S.t -> 'f Monads.Std.Monad.S.t
end
module Exn :
sig
val expect :
?finally:(unit -> unit Monads.Std.Monad.S.t) ->
f:(unit -> 'a Monads.Std.Monad.S.t) ->
catch:(exn -> 'a Monads.Std.Monad.S.t) ->
'a Monads.Std.Monad.S.t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a t t -> 'a t t
val all_ignore : 'a t t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
val map : 'a t -> f:('a -> 'b t) -> 'b t t
val iter :
'a t -> f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a t -> f:('a -> 'a -> 'a t) -> 'a option t
val exists : 'a t -> f:('a -> bool t) -> bool t
val for_all : 'a t -> f:('a -> bool t) -> bool t
val count : 'a t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> 'a t) -> 'a t
val find : 'a t -> f:('a -> bool t) -> 'a option t
val find_map :
'a t -> f:('a -> 'b option t) -> 'b option t
val filter : 'a t -> f:('a -> bool t) -> 'a t t
val filter_map :
'a t -> f:('a -> 'b option t) -> 'b t t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a T.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t -> f:('a -> 'a -> 'a t) -> 'a option t
val exists : 'a T.t -> f:('a -> bool t) -> bool t
val for_all : 'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find : 'a T.t -> f:('a -> bool t) -> 'a option t
val find_map :
'a T.t -> f:('a -> 'b option t) -> 'b option t
val filter : 'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t -> f:('a -> 'b option t) -> 'b T.t t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a T.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t -> f:('a -> 'a -> 'a t) -> 'a option t
val exists : 'a T.t -> f:('a -> bool t) -> bool t
val for_all : 'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find : 'a T.t -> f:('a -> bool t) -> 'a option t
val find_map :
'a T.t -> f:('a -> 'b option t) -> 'b option t
val filter : 'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t -> f:('a -> 'b option t) -> 'b T.t t
end
end
module List :
sig
val all : 'a t list -> 'a list t
val all_ignore : 'a t list -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
val map : 'a list -> f:('a -> 'b t) -> 'b list t
val iter :
'a list -> f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a list -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a list -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a list -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce : 'a list -> f:('a -> 'a -> 'a t) -> 'a option t
val exists : 'a list -> f:('a -> bool t) -> bool t
val for_all : 'a list -> f:('a -> bool t) -> bool t
val count : 'a list -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list -> f:('b -> 'a t) -> 'a t
val find : 'a list -> f:('a -> bool t) -> 'a option t
val find_map :
'a list -> f:('a -> 'b option t) -> 'b option t
val filter : 'a list -> f:('a -> bool t) -> 'a list t
val filter_map :
'a list -> f:('a -> 'b option t) -> 'b list t
end
module Seq :
sig
val all :
'a t Core_kernel.Std.Sequence.t ->
'a Core_kernel.Std.Sequence.t t
val all_ignore :
'a t Core_kernel.Std.Sequence.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t Core_kernel.Std.Sequence.t ->
Monoid.Unit.t t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b t) -> 'b Core_kernel.Std.Sequence.t t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> 'a t) -> 'a option t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> bool t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> bool t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t -> f:('b -> 'a t) -> 'a t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> 'a option t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b option t) -> 'b option t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> 'a Core_kernel.Std.Sequence.t t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b option t) -> 'b Core_kernel.Std.Sequence.t t
end
val ( >=> ) : ('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Monad_infix :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
end
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val return : 'a -> 'a t
val map : 'a t -> f:('a -> 'b) -> 'b t
val join : 'a t t -> 'a t
val ignore_m : 'a t -> Monoid.Unit.t t
val all : 'a t list -> 'a list t
val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
module Let_syntax :
sig
val return : 'a -> 'a t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Let_syntax :
sig
val return : 'a -> 'a t
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val map : 'a t -> f:('a -> 'b) -> 'b t
val both : 'a t -> 'b t -> ('a * 'b) t
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
val ( >=> ) : ('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
end
module type S2 =
sig
type ('a, 'e) t
val void :
('a, 'e) Monads.Std.Monad.S2.t ->
(unit, 'e) Monads.Std.Monad.S2.t
val sequence :
(unit, 'e) Monads.Std.Monad.S2.t list ->
(unit, 'e) Monads.Std.Monad.S2.t
val forever :
('a, 'e) Monads.Std.Monad.S2.t ->
('b, 'e) Monads.Std.Monad.S2.t
module Fn :
sig
val id : 'a -> ('a, 'e) Monads.Std.Monad.S2.t
val ignore :
('a, 'e) Monads.Std.Monad.S2.t ->
(unit, 'e) Monads.Std.Monad.S2.t
val nothing : unit -> (unit, 'e) Monads.Std.Monad.S2.t
val non :
('a -> (bool, 'e) Monads.Std.Monad.S2.t) ->
'a -> (bool, 'e) Monads.Std.Monad.S2.t
val apply_n_times :
n:int ->
('a -> ('a, 'e) Monads.Std.Monad.S2.t) ->
'a -> ('a, 'e) Monads.Std.Monad.S2.t
val compose :
('b -> ('c, 'e) Monads.Std.Monad.S2.t) ->
('a -> ('b, 'e) Monads.Std.Monad.S2.t) ->
'a -> ('c, 'e) Monads.Std.Monad.S2.t
end
module Pair :
sig
val fst :
('a * 'b, 'e) Monads.Std.Monad.S2.t ->
('a, 'e) Monads.Std.Monad.S2.t
val snd :
('a * 'b, 'e) Monads.Std.Monad.S2.t ->
('b, 'e) Monads.Std.Monad.S2.t
end
module Triple :
sig
val fst :
('a * 'b * 'c, 'e) Monads.Std.Monad.S2.t ->
('a, 'e) Monads.Std.Monad.S2.t
val snd :
('a * 'b * 'c, 'e) Monads.Std.Monad.S2.t ->
('b, 'e) Monads.Std.Monad.S2.t
val trd :
('a * 'b * 'c, 'e) Monads.Std.Monad.S2.t ->
('c, 'e) Monads.Std.Monad.S2.t
end
module Lift :
sig
val nullary : 'a -> ('a, 'e) Monads.Std.Monad.S2.t
val unary :
('a -> 'b) ->
('a, 'e) Monads.Std.Monad.S2.t ->
('b, 'e) Monads.Std.Monad.S2.t
val binary :
('a -> 'b -> 'c) ->
('a, 'e) Monads.Std.Monad.S2.t ->
('b, 'e) Monads.Std.Monad.S2.t ->
('c, 'e) Monads.Std.Monad.S2.t
val ternary :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) Monads.Std.Monad.S2.t ->
('b, 'e) Monads.Std.Monad.S2.t ->
('c, 'e) Monads.Std.Monad.S2.t ->
('d, 'e) Monads.Std.Monad.S2.t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) Monads.Std.Monad.S2.t ->
('b, 's) Monads.Std.Monad.S2.t ->
('c, 's) Monads.Std.Monad.S2.t ->
('d, 's) Monads.Std.Monad.S2.t ->
('e, 's) Monads.Std.Monad.S2.t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) Monads.Std.Monad.S2.t ->
('b, 's) Monads.Std.Monad.S2.t ->
('c, 's) Monads.Std.Monad.S2.t ->
('d, 's) Monads.Std.Monad.S2.t ->
('e, 's) Monads.Std.Monad.S2.t ->
('f, 's) Monads.Std.Monad.S2.t
end
module Exn :
sig
val expect :
?finally:(unit -> (unit, 's) Monads.Std.Monad.S2.t) ->
f:(unit -> ('a, 's) Monads.Std.Monad.S2.t) ->
catch:(exn -> ('a, 's) Monads.Std.Monad.S2.t) ->
('a, 's) Monads.Std.Monad.S2.t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : ('a, 'e) t t -> ('a t, 'e) t
val all_ignore : ('a, 'e) t t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
val map : 'a t -> f:('a -> ('b, 'e) t) -> ('b t, 'e) t
val iter :
'a t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a option, 'e) t
val exists :
'a t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a t -> f:('a -> (bool, 'e) t) -> ('a option, 'e) t
val find_map :
'a t ->
f:('a -> ('b option, 'e) t) -> ('b option, 'e) t
val filter :
'a t -> f:('a -> (bool, 'e) t) -> ('a t, 'e) t
val filter_map :
'a t -> f:('a -> ('b option, 'e) t) -> ('b t, 'e) t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : ('a, 'e) t T.t -> ('a T.t, 'e) t
val all_ignore :
('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val map :
'a T.t -> f:('a -> ('b, 'e) t) -> ('b T.t, 'e) t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a option, 'e) t
val exists :
'a T.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a T.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a T.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a option, 'e) t
val find_map :
'a T.t ->
f:('a -> ('b option, 'e) t) -> ('b option, 'e) t
val filter :
'a T.t -> f:('a -> (bool, 'e) t) -> ('a T.t, 'e) t
val filter_map :
'a T.t ->
f:('a -> ('b option, 'e) t) -> ('b T.t, 'e) t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : ('a, 'e) t T.t -> ('a T.t, 'e) t
val all_ignore :
('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val map :
'a T.t -> f:('a -> ('b, 'e) t) -> ('b T.t, 'e) t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a option, 'e) t
val exists :
'a T.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a T.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a T.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a option, 'e) t
val find_map :
'a T.t ->
f:('a -> ('b option, 'e) t) -> ('b option, 'e) t
val filter :
'a T.t -> f:('a -> (bool, 'e) t) -> ('a T.t, 'e) t
val filter_map :
'a T.t ->
f:('a -> ('b option, 'e) t) -> ('b T.t, 'e) t
end
end
module List :
sig
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore : ('a, 'e) t list -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
val map :
'a list -> f:('a -> ('b, 'e) t) -> ('b list, 'e) t
val iter :
'a list ->
f:('a -> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
val fold :
'a list ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a list ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a list ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a list ->
f:('a -> 'a -> ('a, 'e) t) -> ('a option, 'e) t
val exists :
'a list -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a list -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a list -> f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a list -> f:('a -> (bool, 'e) t) -> ('a option, 'e) t
val find_map :
'a list ->
f:('a -> ('b option, 'e) t) -> ('b option, 'e) t
val filter :
'a list -> f:('a -> (bool, 'e) t) -> ('a list, 'e) t
val filter_map :
'a list -> f:('a -> ('b option, 'e) t) -> ('b list, 'e) t
end
module Seq :
sig
val all :
('a, 'e) t Core_kernel.Std.Sequence.t ->
('a Core_kernel.Std.Sequence.t, 'e) t
val all_ignore :
('a, 'e) t Core_kernel.Std.Sequence.t ->
(Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t Core_kernel.Std.Sequence.t ->
(Monoid.Unit.t, 'e) t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b, 'e) t) ->
('b Core_kernel.Std.Sequence.t, 'e) t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a option, 'e) t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) -> ('a option, 'e) t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b option, 'e) t) -> ('b option, 'e) t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) ->
('a Core_kernel.Std.Sequence.t, 'e) t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b option, 'e) t) ->
('b Core_kernel.Std.Sequence.t, 'e) t
end
val ( >=> ) :
('a -> ('b, 'e) t) -> ('b -> ('c, 'e) t) -> 'a -> ('c, 'e) t
val ( !! ) : 'a -> ('a, 'e) t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val ( !$$ ) :
('a -> 'b -> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
val ( >>= ) : ('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val bind :
('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
end
val bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val return : 'a -> ('a, 'b) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore :
(Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
module Syntax :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
val ( >=> ) :
('a -> ('b, 'e) t) ->
('b -> ('c, 'e) t) -> 'a -> ('c, 'e) t
val ( !! ) : 'a -> ('a, 'e) t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
end
end
module type Core = Core_kernel.Std.Monad.S
module type Core2 = Core_kernel.Std.Monad.S2
module type Minimal =
sig
type 'a t
val return : 'a -> 'a Monads.Std.Monad.Minimal.t
val bind :
'a Monads.Std.Monad.Minimal.t ->
('a -> 'b Monads.Std.Monad.Minimal.t) ->
'b Monads.Std.Monad.Minimal.t
end
module type Minimal2 =
sig
type ('a, 'e) t
val return : 'a -> ('a, 'e) Monads.Std.Monad.Minimal2.t
val bind :
('a, 'e) Monads.Std.Monad.Minimal2.t ->
('a -> ('b, 'e) Monads.Std.Monad.Minimal2.t) ->
('b, 'e) Monads.Std.Monad.Minimal2.t
end
module Make :
functor (M : Basic) ->
sig
val void : 'a M.t -> Monoid.Unit.t M.t
val sequence : Monoid.Unit.t M.t list -> Monoid.Unit.t M.t
val forever : 'a M.t -> 'b M.t
module Fn :
sig
val id : 'a -> 'a M.t
val ignore : 'a M.t -> Monoid.Unit.t M.t
val nothing : Monoid.Unit.t -> Monoid.Unit.t M.t
val non : ('a -> bool M.t) -> 'a -> bool M.t
val apply_n_times :
n:Monoid.Int.t -> ('a -> 'a M.t) -> 'a -> 'a M.t
val compose :
('b -> 'c M.t) -> ('a -> 'b M.t) -> 'a -> 'c M.t
end
module Pair :
sig
val fst : ('a * 'b) M.t -> 'a M.t
val snd : ('a * 'b) M.t -> 'b M.t
end
module Triple :
sig
val fst : ('a * 'b * 'c) M.t -> 'a M.t
val snd : ('a * 'b * 'c) M.t -> 'b M.t
val trd : ('a * 'b * 'c) M.t -> 'c M.t
end
module Lift :
sig
val nullary : 'a -> 'a M.t
val unary : ('a -> 'b) -> 'a M.t -> 'b M.t
val binary :
('a -> 'b -> 'c) -> 'a M.t -> 'b M.t -> 'c M.t
val ternary :
('a -> 'b -> 'c -> 'd) ->
'a M.t -> 'b M.t -> 'c M.t -> 'd M.t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a M.t -> 'b M.t -> 'c M.t -> 'd M.t -> 'e M.t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a M.t ->
'b M.t -> 'c M.t -> 'd M.t -> 'e M.t -> 'f M.t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t M.t) ->
f:(Monoid.Unit.t -> 'a M.t) ->
catch:(exn -> 'a M.t) -> 'a M.t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a M.t t -> 'a t M.t
val all_ignore : 'a M.t t -> Monoid.Unit.t M.t
val sequence :
Monoid.Unit.t M.t t -> Monoid.Unit.t M.t
val map : 'a t -> f:('a -> 'b M.t) -> 'b t M.t
val iter :
'a t ->
f:('a -> Monoid.Unit.t M.t) -> Monoid.Unit.t M.t
val fold :
'a t -> init:'b -> f:('b -> 'a -> 'b M.t) -> 'b M.t
val fold_left :
'a t -> init:'b -> f:('b -> 'a -> 'b M.t) -> 'b M.t
val fold_right :
'a t -> f:('a -> 'b -> 'b M.t) -> init:'b -> 'b M.t
val reduce :
'a t -> f:('a -> 'a -> 'a M.t) -> 'a option M.t
val exists : 'a t -> f:('a -> bool M.t) -> bool M.t
val for_all : 'a t -> f:('a -> bool M.t) -> bool M.t
val count :
'a t -> f:('a -> bool M.t) -> Monoid.Int.t M.t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> 'a M.t) -> 'a M.t
val find :
'a t -> f:('a -> bool M.t) -> 'a option M.t
val find_map :
'a t -> f:('a -> 'b option M.t) -> 'b option M.t
val filter : 'a t -> f:('a -> bool M.t) -> 'a t M.t
val filter_map :
'a t -> f:('a -> 'b option M.t) -> 'b t M.t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : 'a M.t T.t -> 'a T.t M.t
val all_ignore : 'a M.t T.t -> Monoid.Unit.t M.t
val sequence :
Monoid.Unit.t M.t T.t -> Monoid.Unit.t M.t
val map : 'a T.t -> f:('a -> 'b M.t) -> 'b T.t M.t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t M.t) -> Monoid.Unit.t M.t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b M.t) -> 'b M.t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b M.t) -> 'b M.t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b M.t) -> init:'b -> 'b M.t
val reduce :
'a T.t -> f:('a -> 'a -> 'a M.t) -> 'a option M.t
val exists :
'a T.t -> f:('a -> bool M.t) -> bool M.t
val for_all :
'a T.t -> f:('a -> bool M.t) -> bool M.t
val count :
'a T.t -> f:('a -> bool M.t) -> Monoid.Int.t M.t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a M.t) -> 'a M.t
val find :
'a T.t -> f:('a -> bool M.t) -> 'a option M.t
val find_map :
'a T.t ->
f:('a -> 'b option M.t) -> 'b option M.t
val filter :
'a T.t -> f:('a -> bool M.t) -> 'a T.t M.t
val filter_map :
'a T.t -> f:('a -> 'b option M.t) -> 'b T.t M.t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : 'a M.t T.t -> 'a T.t M.t
val all_ignore : 'a M.t T.t -> Monoid.Unit.t M.t
val sequence :
Monoid.Unit.t M.t T.t -> Monoid.Unit.t M.t
val map : 'a T.t -> f:('a -> 'b M.t) -> 'b T.t M.t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t M.t) -> Monoid.Unit.t M.t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b M.t) -> 'b M.t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b M.t) -> 'b M.t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b M.t) -> init:'b -> 'b M.t
val reduce :
'a T.t -> f:('a -> 'a -> 'a M.t) -> 'a option M.t
val exists :
'a T.t -> f:('a -> bool M.t) -> bool M.t
val for_all :
'a T.t -> f:('a -> bool M.t) -> bool M.t
val count :
'a T.t -> f:('a -> bool M.t) -> Monoid.Int.t M.t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a M.t) -> 'a M.t
val find :
'a T.t -> f:('a -> bool M.t) -> 'a option M.t
val find_map :
'a T.t ->
f:('a -> 'b option M.t) -> 'b option M.t
val filter :
'a T.t -> f:('a -> bool M.t) -> 'a T.t M.t
val filter_map :
'a T.t -> f:('a -> 'b option M.t) -> 'b T.t M.t
end
end
module List :
sig
val all : 'a M.t list -> 'a list M.t
val all_ignore : 'a M.t list -> Monoid.Unit.t M.t
val sequence :
Monoid.Unit.t M.t list -> Monoid.Unit.t M.t
val map : 'a list -> f:('a -> 'b M.t) -> 'b list M.t
val iter :
'a list ->
f:('a -> Monoid.Unit.t M.t) -> Monoid.Unit.t M.t
val fold :
'a list -> init:'b -> f:('b -> 'a -> 'b M.t) -> 'b M.t
val fold_left :
'a list -> init:'b -> f:('b -> 'a -> 'b M.t) -> 'b M.t
val fold_right :
'a list -> f:('a -> 'b -> 'b M.t) -> init:'b -> 'b M.t
val reduce :
'a list -> f:('a -> 'a -> 'a M.t) -> 'a option M.t
val exists : 'a list -> f:('a -> bool M.t) -> bool M.t
val for_all : 'a list -> f:('a -> bool M.t) -> bool M.t
val count :
'a list -> f:('a -> bool M.t) -> Monoid.Int.t M.t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list -> f:('b -> 'a M.t) -> 'a M.t
val find : 'a list -> f:('a -> bool M.t) -> 'a option M.t
val find_map :
'a list -> f:('a -> 'b option M.t) -> 'b option M.t
val filter : 'a list -> f:('a -> bool M.t) -> 'a list M.t
val filter_map :
'a list -> f:('a -> 'b option M.t) -> 'b list M.t
end
module Seq :
sig
val all :
'a M.t Core_kernel.Std.Sequence.t ->
'a Core_kernel.Std.Sequence.t M.t
val all_ignore :
'a M.t Core_kernel.Std.Sequence.t -> Monoid.Unit.t M.t
val sequence :
Monoid.Unit.t M.t Core_kernel.Std.Sequence.t ->
Monoid.Unit.t M.t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b M.t) -> 'b Core_kernel.Std.Sequence.t M.t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> Monoid.Unit.t M.t) -> Monoid.Unit.t M.t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b M.t) -> 'b M.t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b M.t) -> 'b M.t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> 'b M.t) -> init:'b -> 'b M.t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> 'a M.t) -> 'a option M.t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool M.t) -> bool M.t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool M.t) -> bool M.t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool M.t) -> Monoid.Int.t M.t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> 'a M.t) -> 'a M.t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool M.t) -> 'a option M.t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b option M.t) -> 'b option M.t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool M.t) -> 'a Core_kernel.Std.Sequence.t M.t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b option M.t) ->
'b Core_kernel.Std.Sequence.t M.t
end
val ( >=> ) :
('a -> 'b M.t) -> ('b -> 'c M.t) -> 'a -> 'c M.t
val ( !! ) : 'a -> 'a M.t
val ( !$ ) : ('a -> 'b) -> 'a M.t -> 'b M.t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a M.t -> 'b M.t -> 'c M.t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a M.t -> 'b M.t -> 'c M.t -> 'd M.t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a M.t -> 'b M.t -> 'c M.t -> 'd M.t -> 'e M.t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a M.t -> 'b M.t -> 'c M.t -> 'd M.t -> 'e M.t -> 'f M.t
val ( >>= ) : 'a M.t -> ('a -> 'b M.t) -> 'b M.t
val ( >>| ) : 'a M.t -> ('a -> 'b) -> 'b M.t
module Monad_infix :
sig
val ( >>= ) : 'a M.t -> ('a -> 'b M.t) -> 'b M.t
val ( >>| ) : 'a M.t -> ('a -> 'b) -> 'b M.t
end
val bind : 'a M.t -> f:('a -> 'b M.t) -> 'b M.t
val return : 'a -> 'a M.t
val map : 'a M.t -> f:('a -> 'b) -> 'b M.t
val join : 'a M.t M.t -> 'a M.t
val ignore_m : 'a M.t -> Monoid.Unit.t M.t
val all : 'a M.t list -> 'a list M.t
val all_ignore : Monoid.Unit.t M.t list -> Monoid.Unit.t M.t
module Let_syntax :
sig
val return : 'a -> 'a M.t
val ( >>= ) : 'a M.t -> ('a -> 'b M.t) -> 'b M.t
val ( >>| ) : 'a M.t -> ('a -> 'b) -> 'b M.t
module Let_syntax :
sig
val return : 'a -> 'a M.t
val bind : 'a M.t -> f:('a -> 'b M.t) -> 'b M.t
val map : 'a M.t -> f:('a -> 'b) -> 'b M.t
val both : 'a M.t -> 'b M.t -> ('a * 'b) M.t
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) : 'a M.t -> ('a -> 'b M.t) -> 'b M.t
val ( >>| ) : 'a M.t -> ('a -> 'b) -> 'b M.t
val ( >=> ) :
('a -> 'b M.t) -> ('b -> 'c M.t) -> 'a -> 'c M.t
val ( !! ) : 'a -> 'a M.t
val ( !$ ) : ('a -> 'b) -> 'a M.t -> 'b M.t
val ( !$$ ) :
('a -> 'b -> 'c) -> 'a M.t -> 'b M.t -> 'c M.t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a M.t -> 'b M.t -> 'c M.t -> 'd M.t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a M.t -> 'b M.t -> 'c M.t -> 'd M.t -> 'e M.t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a M.t ->
'b M.t -> 'c M.t -> 'd M.t -> 'e M.t -> 'f M.t
end
end
module Make2 :
functor (M : Basic2) ->
sig
val void : ('a, 'e) M.t -> (Monoid.Unit.t, 'e) M.t
val sequence :
(Monoid.Unit.t, 'e) M.t list -> (Monoid.Unit.t, 'e) M.t
val forever : ('a, 'e) M.t -> ('b, 'e) M.t
module Fn :
sig
val id : 'a -> ('a, 'e) M.t
val ignore : ('a, 'e) M.t -> (Monoid.Unit.t, 'e) M.t
val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) M.t
val non : ('a -> (bool, 'e) M.t) -> 'a -> (bool, 'e) M.t
val apply_n_times :
n:Monoid.Int.t ->
('a -> ('a, 'e) M.t) -> 'a -> ('a, 'e) M.t
val compose :
('b -> ('c, 'e) M.t) ->
('a -> ('b, 'e) M.t) -> 'a -> ('c, 'e) M.t
end
module Pair :
sig
val fst : ('a * 'b, 'e) M.t -> ('a, 'e) M.t
val snd : ('a * 'b, 'e) M.t -> ('b, 'e) M.t
end
module Triple :
sig
val fst : ('a * 'b * 'c, 'e) M.t -> ('a, 'e) M.t
val snd : ('a * 'b * 'c, 'e) M.t -> ('b, 'e) M.t
val trd : ('a * 'b * 'c, 'e) M.t -> ('c, 'e) M.t
end
module Lift :
sig
val nullary : 'a -> ('a, 'e) M.t
val unary : ('a -> 'b) -> ('a, 'e) M.t -> ('b, 'e) M.t
val binary :
('a -> 'b -> 'c) ->
('a, 'e) M.t -> ('b, 'e) M.t -> ('c, 'e) M.t
val ternary :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) M.t ->
('b, 'e) M.t -> ('c, 'e) M.t -> ('d, 'e) M.t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) M.t ->
('b, 's) M.t ->
('c, 's) M.t -> ('d, 's) M.t -> ('e, 's) M.t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) M.t ->
('b, 's) M.t ->
('c, 's) M.t ->
('d, 's) M.t -> ('e, 's) M.t -> ('f, 's) M.t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) M.t) ->
f:(Monoid.Unit.t -> ('a, 's) M.t) ->
catch:(exn -> ('a, 's) M.t) -> ('a, 's) M.t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : ('a, 'e) M.t t -> ('a t, 'e) M.t
val all_ignore :
('a, 'e) M.t t -> (Monoid.Unit.t, 'e) M.t
val sequence :
(Monoid.Unit.t, 'e) M.t t ->
(Monoid.Unit.t, 'e) M.t
val map :
'a t -> f:('a -> ('b, 'e) M.t) -> ('b t, 'e) M.t
val iter :
'a t ->
f:('a -> (Monoid.Unit.t, 'e) M.t) ->
(Monoid.Unit.t, 'e) M.t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) M.t) -> ('b, 'e) M.t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) M.t) -> ('b, 'e) M.t
val fold_right :
'a t ->
f:('a -> 'b -> ('b, 'e) M.t) ->
init:'b -> ('b, 'e) M.t
val reduce :
'a t ->
f:('a -> 'a -> ('a, 'e) M.t) -> ('a option, 'e) M.t
val exists :
'a t -> f:('a -> (bool, 'e) M.t) -> (bool, 'e) M.t
val for_all :
'a t -> f:('a -> (bool, 'e) M.t) -> (bool, 'e) M.t
val count :
'a t ->
f:('a -> (bool, 'e) M.t) -> (Monoid.Int.t, 'e) M.t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> ('a, 'e) M.t) -> ('a, 'e) M.t
val find :
'a t ->
f:('a -> (bool, 'e) M.t) -> ('a option, 'e) M.t
val find_map :
'a t ->
f:('a -> ('b option, 'e) M.t) ->
('b option, 'e) M.t
val filter :
'a t -> f:('a -> (bool, 'e) M.t) -> ('a t, 'e) M.t
val filter_map :
'a t ->
f:('a -> ('b option, 'e) M.t) -> ('b t, 'e) M.t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : ('a, 'e) M.t T.t -> ('a T.t, 'e) M.t
val all_ignore :
('a, 'e) M.t T.t -> (Monoid.Unit.t, 'e) M.t
val sequence :
(Monoid.Unit.t, 'e) M.t T.t ->
(Monoid.Unit.t, 'e) M.t
val map :
'a T.t ->
f:('a -> ('b, 'e) M.t) -> ('b T.t, 'e) M.t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) M.t) ->
(Monoid.Unit.t, 'e) M.t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) M.t) -> ('b, 'e) M.t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) M.t) -> ('b, 'e) M.t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) M.t) ->
init:'b -> ('b, 'e) M.t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) M.t) ->
('a option, 'e) M.t
val exists :
'a T.t ->
f:('a -> (bool, 'e) M.t) -> (bool, 'e) M.t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) M.t) -> (bool, 'e) M.t
val count :
'a T.t ->
f:('a -> (bool, 'e) M.t) ->
(Monoid.Int.t, 'e) M.t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> ('a, 'e) M.t) -> ('a, 'e) M.t
val find :
'a T.t ->
f:('a -> (bool, 'e) M.t) -> ('a option, 'e) M.t
val find_map :
'a T.t ->
f:('a -> ('b option, 'e) M.t) ->
('b option, 'e) M.t
val filter :
'a T.t ->
f:('a -> (bool, 'e) M.t) -> ('a T.t, 'e) M.t
val filter_map :
'a T.t ->
f:('a -> ('b option, 'e) M.t) -> ('b T.t, 'e) M.t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : ('a, 'e) M.t T.t -> ('a T.t, 'e) M.t
val all_ignore :
('a, 'e) M.t T.t -> (Monoid.Unit.t, 'e) M.t
val sequence :
(Monoid.Unit.t, 'e) M.t T.t ->
(Monoid.Unit.t, 'e) M.t
val map :
'a T.t ->
f:('a -> ('b, 'e) M.t) -> ('b T.t, 'e) M.t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) M.t) ->
(Monoid.Unit.t, 'e) M.t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) M.t) -> ('b, 'e) M.t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) M.t) -> ('b, 'e) M.t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) M.t) ->
init:'b -> ('b, 'e) M.t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) M.t) ->
('a option, 'e) M.t
val exists :
'a T.t ->
f:('a -> (bool, 'e) M.t) -> (bool, 'e) M.t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) M.t) -> (bool, 'e) M.t
val count :
'a T.t ->
f:('a -> (bool, 'e) M.t) ->
(Monoid.Int.t, 'e) M.t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> ('a, 'e) M.t) -> ('a, 'e) M.t
val find :
'a T.t ->
f:('a -> (bool, 'e) M.t) -> ('a option, 'e) M.t
val find_map :
'a T.t ->
f:('a -> ('b option, 'e) M.t) ->
('b option, 'e) M.t
val filter :
'a T.t ->
f:('a -> (bool, 'e) M.t) -> ('a T.t, 'e) M.t
val filter_map :
'a T.t ->
f:('a -> ('b option, 'e) M.t) -> ('b T.t, 'e) M.t
end
end
module List :
sig
val all : ('a, 'e) M.t list -> ('a list, 'e) M.t
val all_ignore :
('a, 'e) M.t list -> (Monoid.Unit.t, 'e) M.t
val sequence :
(Monoid.Unit.t, 'e) M.t list -> (Monoid.Unit.t, 'e) M.t
val map :
'a list -> f:('a -> ('b, 'e) M.t) -> ('b list, 'e) M.t
val iter :
'a list ->
f:('a -> (Monoid.Unit.t, 'e) M.t) ->
(Monoid.Unit.t, 'e) M.t
val fold :
'a list ->
init:'b -> f:('b -> 'a -> ('b, 'e) M.t) -> ('b, 'e) M.t
val fold_left :
'a list ->
init:'b -> f:('b -> 'a -> ('b, 'e) M.t) -> ('b, 'e) M.t
val fold_right :
'a list ->
f:('a -> 'b -> ('b, 'e) M.t) -> init:'b -> ('b, 'e) M.t
val reduce :
'a list ->
f:('a -> 'a -> ('a, 'e) M.t) -> ('a option, 'e) M.t
val exists :
'a list -> f:('a -> (bool, 'e) M.t) -> (bool, 'e) M.t
val for_all :
'a list -> f:('a -> (bool, 'e) M.t) -> (bool, 'e) M.t
val count :
'a list ->
f:('a -> (bool, 'e) M.t) -> (Monoid.Int.t, 'e) M.t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list -> f:('b -> ('a, 'e) M.t) -> ('a, 'e) M.t
val find :
'a list ->
f:('a -> (bool, 'e) M.t) -> ('a option, 'e) M.t
val find_map :
'a list ->
f:('a -> ('b option, 'e) M.t) -> ('b option, 'e) M.t
val filter :
'a list ->
f:('a -> (bool, 'e) M.t) -> ('a list, 'e) M.t
val filter_map :
'a list ->
f:('a -> ('b option, 'e) M.t) -> ('b list, 'e) M.t
end
module Seq :
sig
val all :
('a, 'e) M.t Core_kernel.Std.Sequence.t ->
('a Core_kernel.Std.Sequence.t, 'e) M.t
val all_ignore :
('a, 'e) M.t Core_kernel.Std.Sequence.t ->
(Monoid.Unit.t, 'e) M.t
val sequence :
(Monoid.Unit.t, 'e) M.t Core_kernel.Std.Sequence.t ->
(Monoid.Unit.t, 'e) M.t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b, 'e) M.t) ->
('b Core_kernel.Std.Sequence.t, 'e) M.t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (Monoid.Unit.t, 'e) M.t) ->
(Monoid.Unit.t, 'e) M.t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) M.t) -> ('b, 'e) M.t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) M.t) -> ('b, 'e) M.t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> ('b, 'e) M.t) -> init:'b -> ('b, 'e) M.t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> ('a, 'e) M.t) -> ('a option, 'e) M.t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) M.t) -> (bool, 'e) M.t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) M.t) -> (bool, 'e) M.t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) M.t) -> (Monoid.Int.t, 'e) M.t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> ('a, 'e) M.t) -> ('a, 'e) M.t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) M.t) -> ('a option, 'e) M.t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b option, 'e) M.t) -> ('b option, 'e) M.t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) M.t) ->
('a Core_kernel.Std.Sequence.t, 'e) M.t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b option, 'e) M.t) ->
('b Core_kernel.Std.Sequence.t, 'e) M.t
end
val ( >=> ) :
('a -> ('b, 'e) M.t) ->
('b -> ('c, 'e) M.t) -> 'a -> ('c, 'e) M.t
val ( !! ) : 'a -> ('a, 'e) M.t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) M.t -> ('b, 'e) M.t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) M.t -> ('b, 'e) M.t -> ('c, 'e) M.t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) M.t ->
('b, 'e) M.t -> ('c, 'e) M.t -> ('d, 'e) M.t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) M.t ->
('b, 's) M.t ->
('c, 's) M.t -> ('d, 's) M.t -> ('e, 's) M.t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) M.t ->
('b, 's) M.t ->
('c, 's) M.t ->
('d, 's) M.t -> ('e, 's) M.t -> ('f, 's) M.t
val ( >>= ) :
('a, 'e) M.t -> ('a -> ('b, 'e) M.t) -> ('b, 'e) M.t
val ( >>| ) : ('a, 'e) M.t -> ('a -> 'b) -> ('b, 'e) M.t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) M.t
val ( >>= ) :
('a, 'e) M.t -> ('a -> ('b, 'e) M.t) -> ('b, 'e) M.t
val ( >>| ) : ('a, 'e) M.t -> ('a -> 'b) -> ('b, 'e) M.t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) M.t
val bind :
('a, 'e) M.t ->
f:('a -> ('b, 'e) M.t) -> ('b, 'e) M.t
val map :
('a, 'e) M.t -> f:('a -> 'b) -> ('b, 'e) M.t
val both :
('a, 'e) M.t -> ('b, 'e) M.t -> ('a * 'b, 'e) M.t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) M.t -> ('a -> ('b, 'e) M.t) -> ('b, 'e) M.t
val ( >>| ) : ('a, 'e) M.t -> ('a -> 'b) -> ('b, 'e) M.t
end
val bind :
('a, 'e) M.t -> f:('a -> ('b, 'e) M.t) -> ('b, 'e) M.t
val return : 'a -> ('a, 'b) M.t
val map : ('a, 'e) M.t -> f:('a -> 'b) -> ('b, 'e) M.t
val join : (('a, 'e) M.t, 'e) M.t -> ('a, 'e) M.t
val ignore_m : ('a, 'e) M.t -> (Monoid.Unit.t, 'e) M.t
val all : ('a, 'e) M.t list -> ('a list, 'e) M.t
val all_ignore :
(Monoid.Unit.t, 'e) M.t list -> (Monoid.Unit.t, 'e) M.t
module Syntax :
sig
val ( >>= ) :
('a, 'e) M.t -> ('a -> ('b, 'e) M.t) -> ('b, 'e) M.t
val ( >>| ) : ('a, 'e) M.t -> ('a -> 'b) -> ('b, 'e) M.t
val ( >=> ) :
('a -> ('b, 'e) M.t) ->
('b -> ('c, 'e) M.t) -> 'a -> ('c, 'e) M.t
val ( !! ) : 'a -> ('a, 'e) M.t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) M.t -> ('b, 'e) M.t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) M.t -> ('b, 'e) M.t -> ('c, 'e) M.t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) M.t ->
('b, 'e) M.t -> ('c, 'e) M.t -> ('d, 'e) M.t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) M.t ->
('b, 's) M.t ->
('c, 's) M.t -> ('d, 's) M.t -> ('e, 's) M.t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) M.t ->
('b, 's) M.t ->
('c, 's) M.t ->
('d, 's) M.t -> ('e, 's) M.t -> ('f, 's) M.t
end
end
module Core :
functor (M : Core) ->
sig
type 'a t = 'a M.t
val void : 'a t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
val forever : 'a t -> 'b t
module Fn :
sig
val id : 'a -> 'a t
val ignore : 'a t -> Monoid.Unit.t t
val nothing : Monoid.Unit.t -> Monoid.Unit.t t
val non : ('a -> bool t) -> 'a -> bool t
val apply_n_times :
n:Monoid.Int.t -> ('a -> 'a t) -> 'a -> 'a t
val compose : ('b -> 'c t) -> ('a -> 'b t) -> 'a -> 'c t
end
module Pair :
sig
val fst : ('a * 'b) t -> 'a t
val snd : ('a * 'b) t -> 'b t
end
module Triple :
sig
val fst : ('a * 'b * 'c) t -> 'a t
val snd : ('a * 'b * 'c) t -> 'b t
val trd : ('a * 'b * 'c) t -> 'c t
end
module Lift :
sig
val nullary : 'a -> 'a t
val unary : ('a -> 'b) -> 'a t -> 'b t
val binary : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ternary :
('a -> 'b -> 'c -> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
f:(Monoid.Unit.t -> 'a t) ->
catch:(exn -> 'a t) -> 'a t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a M.t t -> 'a t M.t
val all_ignore : 'a M.t t -> Monoid.Unit.t M.t
val sequence :
Monoid.Unit.t M.t t -> Monoid.Unit.t M.t
val map : 'a t -> f:('a -> 'b M.t) -> 'b t M.t
val iter :
'a t ->
f:('a -> Monoid.Unit.t M.t) -> Monoid.Unit.t M.t
val fold :
'a t -> init:'b -> f:('b -> 'a -> 'b M.t) -> 'b M.t
val fold_left :
'a t -> init:'b -> f:('b -> 'a -> 'b M.t) -> 'b M.t
val fold_right :
'a t -> f:('a -> 'b -> 'b M.t) -> init:'b -> 'b M.t
val reduce :
'a t -> f:('a -> 'a -> 'a M.t) -> 'a option M.t
val exists : 'a t -> f:('a -> bool M.t) -> bool M.t
val for_all : 'a t -> f:('a -> bool M.t) -> bool M.t
val count :
'a t -> f:('a -> bool M.t) -> Monoid.Int.t M.t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> 'a M.t) -> 'a M.t
val find :
'a t -> f:('a -> bool M.t) -> 'a option M.t
val find_map :
'a t -> f:('a -> 'b option M.t) -> 'b option M.t
val filter : 'a t -> f:('a -> bool M.t) -> 'a t M.t
val filter_map :
'a t -> f:('a -> 'b option M.t) -> 'b t M.t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a T.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t -> f:('a -> 'a -> 'a t) -> 'a option t
val exists : 'a T.t -> f:('a -> bool t) -> bool t
val for_all : 'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a option t
val find_map :
'a T.t -> f:('a -> 'b option t) -> 'b option t
val filter : 'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t -> f:('a -> 'b option t) -> 'b T.t t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a T.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t -> f:('a -> 'a -> 'a t) -> 'a option t
val exists : 'a T.t -> f:('a -> bool t) -> bool t
val for_all : 'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a option t
val find_map :
'a T.t -> f:('a -> 'b option t) -> 'b option t
val filter : 'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t -> f:('a -> 'b option t) -> 'b T.t t
end
end
module List :
sig
val all : 'a t list -> 'a list t
val all_ignore : 'a t list -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
val map : 'a list -> f:('a -> 'b t) -> 'b list t
val iter :
'a list -> f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a list -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a list -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a list -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a list -> f:('a -> 'a -> 'a t) -> 'a option t
val exists : 'a list -> f:('a -> bool t) -> bool t
val for_all : 'a list -> f:('a -> bool t) -> bool t
val count : 'a list -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list -> f:('b -> 'a t) -> 'a t
val find : 'a list -> f:('a -> bool t) -> 'a option t
val find_map :
'a list -> f:('a -> 'b option t) -> 'b option t
val filter : 'a list -> f:('a -> bool t) -> 'a list t
val filter_map :
'a list -> f:('a -> 'b option t) -> 'b list t
end
module Seq :
sig
val all :
'a t Core_kernel.Std.Sequence.t ->
'a Core_kernel.Std.Sequence.t t
val all_ignore :
'a t Core_kernel.Std.Sequence.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t Core_kernel.Std.Sequence.t ->
Monoid.Unit.t t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b t) -> 'b Core_kernel.Std.Sequence.t t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> 'a t) -> 'a option t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> bool t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> bool t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t -> f:('b -> 'a t) -> 'a t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> 'a option t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b option t) -> 'b option t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> 'a Core_kernel.Std.Sequence.t t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b option t) ->
'b Core_kernel.Std.Sequence.t t
end
val ( >=> ) : ('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Monad_infix :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
end
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val return : 'a -> 'a t
val map : 'a t -> f:('a -> 'b) -> 'b t
val join : 'a t t -> 'a t
val ignore_m : 'a t -> Monoid.Unit.t t
val all : 'a t list -> 'a list t
val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
module Let_syntax :
sig
val return : 'a -> 'a t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Let_syntax :
sig
val return : 'a -> 'a t
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val map : 'a t -> f:('a -> 'b) -> 'b t
val both : 'a t -> 'b t -> ('a * 'b) t
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
val ( >=> ) : ('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
end
module Core2 :
functor (M : Core2) ->
sig
type ('a, 'e) t = ('a, 'e) M.t
val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
val forever : ('a, 'e) t -> ('b, 'e) t
module Fn :
sig
val id : 'a -> ('a, 'e) t
val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
val non : ('a -> (bool, 'e) t) -> 'a -> (bool, 'e) t
val apply_n_times :
n:Monoid.Int.t ->
('a -> ('a, 'e) t) -> 'a -> ('a, 'e) t
val compose :
('b -> ('c, 'e) t) ->
('a -> ('b, 'e) t) -> 'a -> ('c, 'e) t
end
module Pair :
sig
val fst : ('a * 'b, 'e) t -> ('a, 'e) t
val snd : ('a * 'b, 'e) t -> ('b, 'e) t
end
module Triple :
sig
val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
end
module Lift :
sig
val nullary : 'a -> ('a, 'e) t
val unary : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val binary :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ternary :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
f:(Monoid.Unit.t -> ('a, 's) t) ->
catch:(exn -> ('a, 's) t) -> ('a, 's) t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : ('a, 'e) M.t t -> ('a t, 'e) M.t
val all_ignore :
('a, 'e) M.t t -> (Monoid.Unit.t, 'e) M.t
val sequence :
(Monoid.Unit.t, 'e) M.t t ->
(Monoid.Unit.t, 'e) M.t
val map :
'a t -> f:('a -> ('b, 'e) M.t) -> ('b t, 'e) M.t
val iter :
'a t ->
f:('a -> (Monoid.Unit.t, 'e) M.t) ->
(Monoid.Unit.t, 'e) M.t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) M.t) -> ('b, 'e) M.t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) M.t) -> ('b, 'e) M.t
val fold_right :
'a t ->
f:('a -> 'b -> ('b, 'e) M.t) ->
init:'b -> ('b, 'e) M.t
val reduce :
'a t ->
f:('a -> 'a -> ('a, 'e) M.t) -> ('a option, 'e) M.t
val exists :
'a t -> f:('a -> (bool, 'e) M.t) -> (bool, 'e) M.t
val for_all :
'a t -> f:('a -> (bool, 'e) M.t) -> (bool, 'e) M.t
val count :
'a t ->
f:('a -> (bool, 'e) M.t) -> (Monoid.Int.t, 'e) M.t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> ('a, 'e) M.t) -> ('a, 'e) M.t
val find :
'a t ->
f:('a -> (bool, 'e) M.t) -> ('a option, 'e) M.t
val find_map :
'a t ->
f:('a -> ('b option, 'e) M.t) ->
('b option, 'e) M.t
val filter :
'a t -> f:('a -> (bool, 'e) M.t) -> ('a t, 'e) M.t
val filter_map :
'a t ->
f:('a -> ('b option, 'e) M.t) -> ('b t, 'e) M.t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : ('a, 'e) t T.t -> ('a T.t, 'e) t
val all_ignore :
('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t T.t ->
(Monoid.Unit.t, 'e) t
val map :
'a T.t -> f:('a -> ('b, 'e) t) -> ('b T.t, 'e) t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a option, 'e) t
val exists :
'a T.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a T.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a T.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a option, 'e) t
val find_map :
'a T.t ->
f:('a -> ('b option, 'e) t) -> ('b option, 'e) t
val filter :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a T.t, 'e) t
val filter_map :
'a T.t ->
f:('a -> ('b option, 'e) t) -> ('b T.t, 'e) t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : ('a, 'e) t T.t -> ('a T.t, 'e) t
val all_ignore :
('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t T.t ->
(Monoid.Unit.t, 'e) t
val map :
'a T.t -> f:('a -> ('b, 'e) t) -> ('b T.t, 'e) t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a option, 'e) t
val exists :
'a T.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a T.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a T.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a option, 'e) t
val find_map :
'a T.t ->
f:('a -> ('b option, 'e) t) -> ('b option, 'e) t
val filter :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a T.t, 'e) t
val filter_map :
'a T.t ->
f:('a -> ('b option, 'e) t) -> ('b T.t, 'e) t
end
end
module List :
sig
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore : ('a, 'e) t list -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
val map :
'a list -> f:('a -> ('b, 'e) t) -> ('b list, 'e) t
val iter :
'a list ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a list ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a list ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a list ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a list ->
f:('a -> 'a -> ('a, 'e) t) -> ('a option, 'e) t
val exists :
'a list -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a list -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a list ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a list -> f:('a -> (bool, 'e) t) -> ('a option, 'e) t
val find_map :
'a list ->
f:('a -> ('b option, 'e) t) -> ('b option, 'e) t
val filter :
'a list -> f:('a -> (bool, 'e) t) -> ('a list, 'e) t
val filter_map :
'a list ->
f:('a -> ('b option, 'e) t) -> ('b list, 'e) t
end
module Seq :
sig
val all :
('a, 'e) t Core_kernel.Std.Sequence.t ->
('a Core_kernel.Std.Sequence.t, 'e) t
val all_ignore :
('a, 'e) t Core_kernel.Std.Sequence.t ->
(Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t Core_kernel.Std.Sequence.t ->
(Monoid.Unit.t, 'e) t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b, 'e) t) ->
('b Core_kernel.Std.Sequence.t, 'e) t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a option, 'e) t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) -> ('a option, 'e) t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b option, 'e) t) -> ('b option, 'e) t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) ->
('a Core_kernel.Std.Sequence.t, 'e) t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b option, 'e) t) ->
('b Core_kernel.Std.Sequence.t, 'e) t
end
val ( >=> ) :
('a -> ('b, 'e) t) ->
('b -> ('c, 'e) t) -> 'a -> ('c, 'e) t
val ( !! ) : 'a -> ('a, 'e) t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val ( !$$ ) :
('a -> 'b -> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
val ( >>= ) : ('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val bind :
('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val both :
('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
end
val bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val return : 'a -> ('a, 'b) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore :
(Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
module Syntax :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
val ( >=> ) :
('a -> ('b, 'e) t) ->
('b -> ('c, 'e) t) -> 'a -> ('c, 'e) t
val ( !! ) : 'a -> ('a, 'e) t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
end
end
module Minimal :
functor (M : Minimal) ->
sig
type 'a t = 'a M.t
val void : 'a t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
val forever : 'a t -> 'b t
module Fn :
sig
val id : 'a -> 'a t
val ignore : 'a t -> Monoid.Unit.t t
val nothing : Monoid.Unit.t -> Monoid.Unit.t t
val non : ('a -> bool t) -> 'a -> bool t
val apply_n_times :
n:Monoid.Int.t -> ('a -> 'a t) -> 'a -> 'a t
val compose : ('b -> 'c t) -> ('a -> 'b t) -> 'a -> 'c t
end
module Pair :
sig
val fst : ('a * 'b) t -> 'a t
val snd : ('a * 'b) t -> 'b t
end
module Triple :
sig
val fst : ('a * 'b * 'c) t -> 'a t
val snd : ('a * 'b * 'c) t -> 'b t
val trd : ('a * 'b * 'c) t -> 'c t
end
module Lift :
sig
val nullary : 'a -> 'a t
val unary : ('a -> 'b) -> 'a t -> 'b t
val binary : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ternary :
('a -> 'b -> 'c -> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
f:(Monoid.Unit.t -> 'a t) ->
catch:(exn -> 'a t) -> 'a t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a M.t t -> 'a t M.t
val all_ignore : 'a M.t t -> Monoid.Unit.t M.t
val sequence :
Monoid.Unit.t M.t t -> Monoid.Unit.t M.t
val map : 'a t -> f:('a -> 'b M.t) -> 'b t M.t
val iter :
'a t ->
f:('a -> Monoid.Unit.t M.t) -> Monoid.Unit.t M.t
val fold :
'a t -> init:'b -> f:('b -> 'a -> 'b M.t) -> 'b M.t
val fold_left :
'a t -> init:'b -> f:('b -> 'a -> 'b M.t) -> 'b M.t
val fold_right :
'a t -> f:('a -> 'b -> 'b M.t) -> init:'b -> 'b M.t
val reduce :
'a t -> f:('a -> 'a -> 'a M.t) -> 'a option M.t
val exists : 'a t -> f:('a -> bool M.t) -> bool M.t
val for_all : 'a t -> f:('a -> bool M.t) -> bool M.t
val count :
'a t -> f:('a -> bool M.t) -> Monoid.Int.t M.t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> 'a M.t) -> 'a M.t
val find :
'a t -> f:('a -> bool M.t) -> 'a option M.t
val find_map :
'a t -> f:('a -> 'b option M.t) -> 'b option M.t
val filter : 'a t -> f:('a -> bool M.t) -> 'a t M.t
val filter_map :
'a t -> f:('a -> 'b option M.t) -> 'b t M.t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a T.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t -> f:('a -> 'a -> 'a t) -> 'a option t
val exists : 'a T.t -> f:('a -> bool t) -> bool t
val for_all : 'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a option t
val find_map :
'a T.t -> f:('a -> 'b option t) -> 'b option t
val filter : 'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t -> f:('a -> 'b option t) -> 'b T.t t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a T.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t -> f:('a -> 'a -> 'a t) -> 'a option t
val exists : 'a T.t -> f:('a -> bool t) -> bool t
val for_all : 'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a option t
val find_map :
'a T.t -> f:('a -> 'b option t) -> 'b option t
val filter : 'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t -> f:('a -> 'b option t) -> 'b T.t t
end
end
module List :
sig
val all : 'a t list -> 'a list t
val all_ignore : 'a t list -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
val map : 'a list -> f:('a -> 'b t) -> 'b list t
val iter :
'a list -> f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a list -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a list -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a list -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a list -> f:('a -> 'a -> 'a t) -> 'a option t
val exists : 'a list -> f:('a -> bool t) -> bool t
val for_all : 'a list -> f:('a -> bool t) -> bool t
val count : 'a list -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list -> f:('b -> 'a t) -> 'a t
val find : 'a list -> f:('a -> bool t) -> 'a option t
val find_map :
'a list -> f:('a -> 'b option t) -> 'b option t
val filter : 'a list -> f:('a -> bool t) -> 'a list t
val filter_map :
'a list -> f:('a -> 'b option t) -> 'b list t
end
module Seq :
sig
val all :
'a t Core_kernel.Std.Sequence.t ->
'a Core_kernel.Std.Sequence.t t
val all_ignore :
'a t Core_kernel.Std.Sequence.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t Core_kernel.Std.Sequence.t ->
Monoid.Unit.t t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b t) -> 'b Core_kernel.Std.Sequence.t t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> 'a t) -> 'a option t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> bool t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> bool t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t -> f:('b -> 'a t) -> 'a t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> 'a option t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b option t) -> 'b option t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> 'a Core_kernel.Std.Sequence.t t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b option t) ->
'b Core_kernel.Std.Sequence.t t
end
val ( >=> ) : ('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Monad_infix :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
end
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val return : 'a -> 'a t
val map : 'a t -> f:('a -> 'b) -> 'b t
val join : 'a t t -> 'a t
val ignore_m : 'a t -> Monoid.Unit.t t
val all : 'a t list -> 'a list t
val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
module Let_syntax :
sig
val return : 'a -> 'a t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Let_syntax :
sig
val return : 'a -> 'a t
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val map : 'a t -> f:('a -> 'b) -> 'b t
val both : 'a t -> 'b t -> ('a * 'b) t
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
val ( >=> ) : ('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
end
module Minimal2 :
functor (M : Minimal2) ->
sig
type ('a, 'e) t = ('a, 'e) M.t
val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
val forever : ('a, 'e) t -> ('b, 'e) t
module Fn :
sig
val id : 'a -> ('a, 'e) t
val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
val non : ('a -> (bool, 'e) t) -> 'a -> (bool, 'e) t
val apply_n_times :
n:Monoid.Int.t ->
('a -> ('a, 'e) t) -> 'a -> ('a, 'e) t
val compose :
('b -> ('c, 'e) t) ->
('a -> ('b, 'e) t) -> 'a -> ('c, 'e) t
end
module Pair :
sig
val fst : ('a * 'b, 'e) t -> ('a, 'e) t
val snd : ('a * 'b, 'e) t -> ('b, 'e) t
end
module Triple :
sig
val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
end
module Lift :
sig
val nullary : 'a -> ('a, 'e) t
val unary : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val binary :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ternary :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
f:(Monoid.Unit.t -> ('a, 's) t) ->
catch:(exn -> ('a, 's) t) -> ('a, 's) t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : ('a, 'e) M.t t -> ('a t, 'e) M.t
val all_ignore :
('a, 'e) M.t t -> (Monoid.Unit.t, 'e) M.t
val sequence :
(Monoid.Unit.t, 'e) M.t t ->
(Monoid.Unit.t, 'e) M.t
val map :
'a t -> f:('a -> ('b, 'e) M.t) -> ('b t, 'e) M.t
val iter :
'a t ->
f:('a -> (Monoid.Unit.t, 'e) M.t) ->
(Monoid.Unit.t, 'e) M.t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) M.t) -> ('b, 'e) M.t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) M.t) -> ('b, 'e) M.t
val fold_right :
'a t ->
f:('a -> 'b -> ('b, 'e) M.t) ->
init:'b -> ('b, 'e) M.t
val reduce :
'a t ->
f:('a -> 'a -> ('a, 'e) M.t) -> ('a option, 'e) M.t
val exists :
'a t -> f:('a -> (bool, 'e) M.t) -> (bool, 'e) M.t
val for_all :
'a t -> f:('a -> (bool, 'e) M.t) -> (bool, 'e) M.t
val count :
'a t ->
f:('a -> (bool, 'e) M.t) -> (Monoid.Int.t, 'e) M.t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> ('a, 'e) M.t) -> ('a, 'e) M.t
val find :
'a t ->
f:('a -> (bool, 'e) M.t) -> ('a option, 'e) M.t
val find_map :
'a t ->
f:('a -> ('b option, 'e) M.t) ->
('b option, 'e) M.t
val filter :
'a t -> f:('a -> (bool, 'e) M.t) -> ('a t, 'e) M.t
val filter_map :
'a t ->
f:('a -> ('b option, 'e) M.t) -> ('b t, 'e) M.t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : ('a, 'e) t T.t -> ('a T.t, 'e) t
val all_ignore :
('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t T.t ->
(Monoid.Unit.t, 'e) t
val map :
'a T.t -> f:('a -> ('b, 'e) t) -> ('b T.t, 'e) t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a option, 'e) t
val exists :
'a T.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a T.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a T.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a option, 'e) t
val find_map :
'a T.t ->
f:('a -> ('b option, 'e) t) -> ('b option, 'e) t
val filter :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a T.t, 'e) t
val filter_map :
'a T.t ->
f:('a -> ('b option, 'e) t) -> ('b T.t, 'e) t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : ('a, 'e) t T.t -> ('a T.t, 'e) t
val all_ignore :
('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t T.t ->
(Monoid.Unit.t, 'e) t
val map :
'a T.t -> f:('a -> ('b, 'e) t) -> ('b T.t, 'e) t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a option, 'e) t
val exists :
'a T.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a T.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a T.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a option, 'e) t
val find_map :
'a T.t ->
f:('a -> ('b option, 'e) t) -> ('b option, 'e) t
val filter :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a T.t, 'e) t
val filter_map :
'a T.t ->
f:('a -> ('b option, 'e) t) -> ('b T.t, 'e) t
end
end
module List :
sig
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore : ('a, 'e) t list -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
val map :
'a list -> f:('a -> ('b, 'e) t) -> ('b list, 'e) t
val iter :
'a list ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a list ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a list ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a list ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a list ->
f:('a -> 'a -> ('a, 'e) t) -> ('a option, 'e) t
val exists :
'a list -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a list -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a list ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a list -> f:('a -> (bool, 'e) t) -> ('a option, 'e) t
val find_map :
'a list ->
f:('a -> ('b option, 'e) t) -> ('b option, 'e) t
val filter :
'a list -> f:('a -> (bool, 'e) t) -> ('a list, 'e) t
val filter_map :
'a list ->
f:('a -> ('b option, 'e) t) -> ('b list, 'e) t
end
module Seq :
sig
val all :
('a, 'e) t Core_kernel.Std.Sequence.t ->
('a Core_kernel.Std.Sequence.t, 'e) t
val all_ignore :
('a, 'e) t Core_kernel.Std.Sequence.t ->
(Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t Core_kernel.Std.Sequence.t ->
(Monoid.Unit.t, 'e) t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b, 'e) t) ->
('b Core_kernel.Std.Sequence.t, 'e) t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a option, 'e) t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) -> ('a option, 'e) t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b option, 'e) t) -> ('b option, 'e) t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) ->
('a Core_kernel.Std.Sequence.t, 'e) t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b option, 'e) t) ->
('b Core_kernel.Std.Sequence.t, 'e) t
end
val ( >=> ) :
('a -> ('b, 'e) t) ->
('b -> ('c, 'e) t) -> 'a -> ('c, 'e) t
val ( !! ) : 'a -> ('a, 'e) t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val ( !$$ ) :
('a -> 'b -> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
val ( >>= ) : ('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val bind :
('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val both :
('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
end
val bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val return : 'a -> ('a, 'b) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore :
(Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
module Syntax :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
val ( >=> ) :
('a -> ('b, 'e) t) ->
('b -> ('c, 'e) t) -> 'a -> ('c, 'e) t
val ( !! ) : 'a -> ('a, 'e) t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
end
end
module type Monad = S
module type Monad2 = S2
module Ident :
sig
type 'a t = 'a
val void : 'a -> Monoid.Unit.t
val sequence : Monoid.Unit.t list -> Monoid.Unit.t
val forever : 'a -> 'b
module Fn :
sig
val id : 'a -> 'a
val ignore : 'a -> Monoid.Unit.t
val nothing : Monoid.Unit.t -> Monoid.Unit.t
val non : ('a -> bool) -> 'a -> bool
val apply_n_times :
n:Monoid.Int.t -> ('a -> 'a) -> 'a -> 'a
val compose : ('b -> 'c) -> ('a -> 'b) -> 'a -> 'c
end
module Pair :
sig val fst : 'a * 'b -> 'a val snd : 'a * 'b -> 'b end
module Triple :
sig
val fst : 'a * 'b * 'c -> 'a
val snd : 'a * 'b * 'c -> 'b
val trd : 'a * 'b * 'c -> 'c
end
module Lift :
sig
val nullary : 'a -> 'a
val unary : ('a -> 'b) -> 'a -> 'b
val binary : ('a -> 'b -> 'c) -> 'a -> 'b -> 'c
val ternary :
('a -> 'b -> 'c -> 'd) -> 'a -> 'b -> 'c -> 'd
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a -> 'b -> 'c -> 'd -> 'e
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a -> 'b -> 'c -> 'd -> 'e -> 'f
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t) ->
f:(Monoid.Unit.t -> 'a) -> catch:(exn -> 'a) -> 'a
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a t -> 'a t
val all_ignore : 'a t -> Monoid.Unit.t
val sequence : Monoid.Unit.t t -> Monoid.Unit.t
val map : 'a t -> f:('a -> 'b) -> 'b t
val iter :
'a t -> f:('a -> Monoid.Unit.t) -> Monoid.Unit.t
val fold : 'a t -> init:'b -> f:('b -> 'a -> 'b) -> 'b
val fold_left :
'a t -> init:'b -> f:('b -> 'a -> 'b) -> 'b
val fold_right :
'a t -> f:('a -> 'b -> 'b) -> init:'b -> 'b
val reduce : 'a t -> f:('a -> 'a -> 'a) -> 'a option
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> Monoid.Int.t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> 'a) -> 'a
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val filter : 'a t -> f:('a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : 'a T.t -> 'a T.t
val all_ignore : 'a T.t -> Monoid.Unit.t
val sequence : Monoid.Unit.t T.t -> Monoid.Unit.t
val map : 'a T.t -> f:('a -> 'b) -> 'b T.t
val iter :
'a T.t -> f:('a -> Monoid.Unit.t) -> Monoid.Unit.t
val fold :
'a T.t -> init:'b -> f:('b -> 'a -> 'b) -> 'b
val fold_left :
'a T.t -> init:'b -> f:('b -> 'a -> 'b) -> 'b
val fold_right :
'a T.t -> f:('a -> 'b -> 'b) -> init:'b -> 'b
val reduce :
'a T.t -> f:('a -> 'a -> 'a) -> 'a option
val exists : 'a T.t -> f:('a -> bool) -> bool
val for_all : 'a T.t -> f:('a -> bool) -> bool
val count : 'a T.t -> f:('a -> bool) -> Monoid.Int.t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a) -> 'a
val find : 'a T.t -> f:('a -> bool) -> 'a option
val find_map :
'a T.t -> f:('a -> 'b option) -> 'b option
val filter : 'a T.t -> f:('a -> bool) -> 'a T.t
val filter_map :
'a T.t -> f:('a -> 'b option) -> 'b T.t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : 'a T.t -> 'a T.t
val all_ignore : 'a T.t -> Monoid.Unit.t
val sequence : Monoid.Unit.t T.t -> Monoid.Unit.t
val map : 'a T.t -> f:('a -> 'b) -> 'b T.t
val iter :
'a T.t -> f:('a -> Monoid.Unit.t) -> Monoid.Unit.t
val fold :
'a T.t -> init:'b -> f:('b -> 'a -> 'b) -> 'b
val fold_left :
'a T.t -> init:'b -> f:('b -> 'a -> 'b) -> 'b
val fold_right :
'a T.t -> f:('a -> 'b -> 'b) -> init:'b -> 'b
val reduce :
'a T.t -> f:('a -> 'a -> 'a) -> 'a option
val exists : 'a T.t -> f:('a -> bool) -> bool
val for_all : 'a T.t -> f:('a -> bool) -> bool
val count : 'a T.t -> f:('a -> bool) -> Monoid.Int.t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a) -> 'a
val find : 'a T.t -> f:('a -> bool) -> 'a option
val find_map :
'a T.t -> f:('a -> 'b option) -> 'b option
val filter : 'a T.t -> f:('a -> bool) -> 'a T.t
val filter_map :
'a T.t -> f:('a -> 'b option) -> 'b T.t
end
end
module List :
sig
val all : 'a list -> 'a list
val all_ignore : 'a list -> Monoid.Unit.t
val sequence : Monoid.Unit.t list -> Monoid.Unit.t
val map : 'a list -> f:('a -> 'b) -> 'b list
val iter :
'a list -> f:('a -> Monoid.Unit.t) -> Monoid.Unit.t
val fold : 'a list -> init:'b -> f:('b -> 'a -> 'b) -> 'b
val fold_left :
'a list -> init:'b -> f:('b -> 'a -> 'b) -> 'b
val fold_right :
'a list -> f:('a -> 'b -> 'b) -> init:'b -> 'b
val reduce : 'a list -> f:('a -> 'a -> 'a) -> 'a option
val exists : 'a list -> f:('a -> bool) -> bool
val for_all : 'a list -> f:('a -> bool) -> bool
val count : 'a list -> f:('a -> bool) -> Monoid.Int.t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list -> f:('b -> 'a) -> 'a
val find : 'a list -> f:('a -> bool) -> 'a option
val find_map : 'a list -> f:('a -> 'b option) -> 'b option
val filter : 'a list -> f:('a -> bool) -> 'a list
val filter_map : 'a list -> f:('a -> 'b option) -> 'b list
end
module Seq :
sig
val all :
'a Core_kernel.Std.Sequence.t ->
'a Core_kernel.Std.Sequence.t
val all_ignore :
'a Core_kernel.Std.Sequence.t -> Monoid.Unit.t
val sequence :
Monoid.Unit.t Core_kernel.Std.Sequence.t -> Monoid.Unit.t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b) -> 'b Core_kernel.Std.Sequence.t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> Monoid.Unit.t) -> Monoid.Unit.t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b) -> 'b
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b) -> 'b
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> 'b) -> init:'b -> 'b
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> 'a) -> 'a option
val exists :
'a Core_kernel.Std.Sequence.t -> f:('a -> bool) -> bool
val for_all :
'a Core_kernel.Std.Sequence.t -> f:('a -> bool) -> bool
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool) -> Monoid.Int.t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t -> f:('b -> 'a) -> 'a
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool) -> 'a option
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b option) -> 'b option
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool) -> 'a Core_kernel.Std.Sequence.t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b option) -> 'b Core_kernel.Std.Sequence.t
end
val ( >=> ) : ('a -> 'b) -> ('b -> 'c) -> 'a -> 'c
val ( !! ) : 'a -> 'a
val ( !$ ) : ('a -> 'b) -> 'a -> 'b
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a -> 'b -> 'c
val ( !$$$ ) : ('a -> 'b -> 'c -> 'd) -> 'a -> 'b -> 'c -> 'd
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) -> 'a -> 'b -> 'c -> 'd -> 'e
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a -> 'b -> 'c -> 'd -> 'e -> 'f
val ( >>= ) : 'a -> ('a -> 'b) -> 'b
val ( >>| ) : 'a -> ('a -> 'b) -> 'b
module Monad_infix :
sig
val ( >>= ) : 'a -> ('a -> 'b) -> 'b
val ( >>| ) : 'a -> ('a -> 'b) -> 'b
end
val bind : 'a -> f:('a -> 'b) -> 'b
val return : 'a -> 'a
val map : 'a -> f:('a -> 'b) -> 'b
val join : 'a -> 'a
val ignore_m : 'a -> Monoid.Unit.t
val all : 'a list -> 'a list
val all_ignore : Monoid.Unit.t list -> Monoid.Unit.t
module Let_syntax :
sig
val return : 'a -> 'a
val ( >>= ) : 'a -> ('a -> 'b) -> 'b
val ( >>| ) : 'a -> ('a -> 'b) -> 'b
module Let_syntax :
sig
val return : 'a -> 'a
val bind : 'a -> f:('a -> 'b) -> 'b
val map : 'a -> f:('a -> 'b) -> 'b
val both : 'a -> 'b -> 'a * 'b
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) : 'a -> ('a -> 'b) -> 'b
val ( >>| ) : 'a -> ('a -> 'b) -> 'b
val ( >=> ) : ('a -> 'b) -> ('b -> 'c) -> 'a -> 'c
val ( !! ) : 'a -> 'a
val ( !$ ) : ('a -> 'b) -> 'a -> 'b
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a -> 'b -> 'c
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) -> 'a -> 'b -> 'c -> 'd
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a -> 'b -> 'c -> 'd -> 'e
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a -> 'b -> 'c -> 'd -> 'e -> 'f
end
end
module Option :
sig
module type S =
sig
type 'a t
type 'a m
type 'a e
val lift : 'a m -> 'a t
val run : 'a t -> 'a e
val void : 'a t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
val forever : 'a t -> 'b t
module Fn :
sig
val id : 'a -> 'a t
val ignore : 'a t -> Monoid.Unit.t t
val nothing : Monoid.Unit.t -> Monoid.Unit.t t
val non : ('a -> bool t) -> 'a -> bool t
val apply_n_times :
n:Monoid.Int.t -> ('a -> 'a t) -> 'a -> 'a t
val compose :
('b -> 'c t) -> ('a -> 'b t) -> 'a -> 'c t
end
module Pair :
sig
val fst : ('a * 'b) t -> 'a t
val snd : ('a * 'b) t -> 'b t
end
module Triple :
sig
val fst : ('a * 'b * 'c) t -> 'a t
val snd : ('a * 'b * 'c) t -> 'b t
val trd : ('a * 'b * 'c) t -> 'c t
end
module Lift :
sig
val nullary : 'a -> 'a t
val unary : ('a -> 'b) -> 'a t -> 'b t
val binary : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ternary :
('a -> 'b -> 'c -> 'd) ->
'a t -> 'b t -> 'c t -> 'd t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
f:(Monoid.Unit.t -> 'a t) ->
catch:(exn -> 'a t) -> 'a t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a t t -> 'a t t
val all_ignore : 'a t t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
val map : 'a t -> f:('a -> 'b t) -> 'b t t
val iter :
'a t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a t -> f:('a -> 'a -> 'a t) -> 'a option t
val exists : 'a t -> f:('a -> bool t) -> bool t
val for_all : 'a t -> f:('a -> bool t) -> bool t
val count :
'a t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> 'a t) -> 'a t
val find : 'a t -> f:('a -> bool t) -> 'a option t
val find_map :
'a t -> f:('a -> 'b option t) -> 'b option t
val filter : 'a t -> f:('a -> bool t) -> 'a t t
val filter_map :
'a t -> f:('a -> 'b option t) -> 'b t t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t -> f:('a -> 'a -> 'a t) -> 'a option t
val exists : 'a T.t -> f:('a -> bool t) -> bool t
val for_all :
'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a option t
val find_map :
'a T.t -> f:('a -> 'b option t) -> 'b option t
val filter :
'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t -> f:('a -> 'b option t) -> 'b T.t t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t -> f:('a -> 'a -> 'a t) -> 'a option t
val exists : 'a T.t -> f:('a -> bool t) -> bool t
val for_all :
'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a option t
val find_map :
'a T.t -> f:('a -> 'b option t) -> 'b option t
val filter :
'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t -> f:('a -> 'b option t) -> 'b T.t t
end
end
module List :
sig
val all : 'a t list -> 'a list t
val all_ignore : 'a t list -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
val map : 'a list -> f:('a -> 'b t) -> 'b list t
val iter :
'a list ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a list -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a list -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a list -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a list -> f:('a -> 'a -> 'a t) -> 'a option t
val exists : 'a list -> f:('a -> bool t) -> bool t
val for_all : 'a list -> f:('a -> bool t) -> bool t
val count :
'a list -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list -> f:('b -> 'a t) -> 'a t
val find : 'a list -> f:('a -> bool t) -> 'a option t
val find_map :
'a list -> f:('a -> 'b option t) -> 'b option t
val filter : 'a list -> f:('a -> bool t) -> 'a list t
val filter_map :
'a list -> f:('a -> 'b option t) -> 'b list t
end
module Seq :
sig
val all :
'a t Core_kernel.Std.Sequence.t ->
'a Core_kernel.Std.Sequence.t t
val all_ignore :
'a t Core_kernel.Std.Sequence.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t Core_kernel.Std.Sequence.t ->
Monoid.Unit.t t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b t) -> 'b Core_kernel.Std.Sequence.t t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> 'a t) -> 'a option t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> bool t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> bool t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> 'a t) -> 'a t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> 'a option t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b option t) -> 'b option t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> 'a Core_kernel.Std.Sequence.t t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b option t) ->
'b Core_kernel.Std.Sequence.t t
end
val ( >=> ) : ('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Monad_infix :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
end
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val return : 'a -> 'a t
val map : 'a t -> f:('a -> 'b) -> 'b t
val join : 'a t t -> 'a t
val ignore_m : 'a t -> Monoid.Unit.t t
val all : 'a t list -> 'a list t
val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
module Let_syntax :
sig
val return : 'a -> 'a t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Let_syntax :
sig
val return : 'a -> 'a t
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val map : 'a t -> f:('a -> 'b) -> 'b t
val both : 'a t -> 'b t -> ('a * 'b) t
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
val ( >=> ) :
('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
val pure : 'a -> 'a t
val accept : 'a -> 'a t
val reject : Monoid.Unit.t -> 'a t
val guard : bool -> Monoid.Unit.t t
val on : bool -> Monoid.Unit.t t -> Monoid.Unit.t t
val unless : bool -> Monoid.Unit.t t -> Monoid.Unit.t t
val zero : Monoid.Unit.t -> 'a t
val plus : 'a t -> 'a t -> 'a t
type 'a error = Monoid.Unit.t
val fail : Monoid.Unit.t -> 'a t
val catch : 'a t -> (Monoid.Unit.t -> 'a t) -> 'a t
end
module type S2 =
sig
type ('a, 'e) t
type ('a, 'e) m
type ('a, 'e) e
val lift : ('a, 'e) m -> ('a, 'e) t
val run : ('a, 'e) t -> ('a, 'e) e
val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
val forever : ('a, 'e) t -> ('b, 'e) t
module Fn :
sig
val id : 'a -> ('a, 'e) t
val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
val non : ('a -> (bool, 'e) t) -> 'a -> (bool, 'e) t
val apply_n_times :
n:Monoid.Int.t ->
('a -> ('a, 'e) t) -> 'a -> ('a, 'e) t
val compose :
('b -> ('c, 'e) t) ->
('a -> ('b, 'e) t) -> 'a -> ('c, 'e) t
end
module Pair :
sig
val fst : ('a * 'b, 'e) t -> ('a, 'e) t
val snd : ('a * 'b, 'e) t -> ('b, 'e) t
end
module Triple :
sig
val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
end
module Lift :
sig
val nullary : 'a -> ('a, 'e) t
val unary : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val binary :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ternary :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
f:(Monoid.Unit.t -> ('a, 's) t) ->
catch:(exn -> ('a, 's) t) -> ('a, 's) t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : ('a, 'e) t t -> ('a t, 'e) t
val all_ignore :
('a, 'e) t t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
val map :
'a t -> f:('a -> ('b, 'e) t) -> ('b t, 'e) t
val iter :
'a t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a option, 'e) t
val exists :
'a t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a t ->
f:('a -> (bool, 'e) t) -> ('a option, 'e) t
val find_map :
'a t ->
f:('a -> ('b option, 'e) t) -> ('b option, 'e) t
val filter :
'a t -> f:('a -> (bool, 'e) t) -> ('a t, 'e) t
val filter_map :
'a t ->
f:('a -> ('b option, 'e) t) -> ('b t, 'e) t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : ('a, 'e) t T.t -> ('a T.t, 'e) t
val all_ignore :
('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t T.t ->
(Monoid.Unit.t, 'e) t
val map :
'a T.t ->
f:('a -> ('b, 'e) t) -> ('b T.t, 'e) t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a option, 'e) t
val exists :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a T.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a option, 'e) t
val find_map :
'a T.t ->
f:('a -> ('b option, 'e) t) ->
('b option, 'e) t
val filter :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a T.t, 'e) t
val filter_map :
'a T.t ->
f:('a -> ('b option, 'e) t) -> ('b T.t, 'e) t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : ('a, 'e) t T.t -> ('a T.t, 'e) t
val all_ignore :
('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t T.t ->
(Monoid.Unit.t, 'e) t
val map :
'a T.t ->
f:('a -> ('b, 'e) t) -> ('b T.t, 'e) t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a option, 'e) t
val exists :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a T.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a option, 'e) t
val find_map :
'a T.t ->
f:('a -> ('b option, 'e) t) ->
('b option, 'e) t
val filter :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a T.t, 'e) t
val filter_map :
'a T.t ->
f:('a -> ('b option, 'e) t) -> ('b T.t, 'e) t
end
end
module List :
sig
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore :
('a, 'e) t list -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
val map :
'a list -> f:('a -> ('b, 'e) t) -> ('b list, 'e) t
val iter :
'a list ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a list ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a list ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a list ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a list ->
f:('a -> 'a -> ('a, 'e) t) -> ('a option, 'e) t
val exists :
'a list -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a list -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a list ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a list ->
f:('a -> (bool, 'e) t) -> ('a option, 'e) t
val find_map :
'a list ->
f:('a -> ('b option, 'e) t) -> ('b option, 'e) t
val filter :
'a list -> f:('a -> (bool, 'e) t) -> ('a list, 'e) t
val filter_map :
'a list ->
f:('a -> ('b option, 'e) t) -> ('b list, 'e) t
end
module Seq :
sig
val all :
('a, 'e) t Core_kernel.Std.Sequence.t ->
('a Core_kernel.Std.Sequence.t, 'e) t
val all_ignore :
('a, 'e) t Core_kernel.Std.Sequence.t ->
(Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t Core_kernel.Std.Sequence.t ->
(Monoid.Unit.t, 'e) t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b, 'e) t) ->
('b Core_kernel.Std.Sequence.t, 'e) t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a option, 'e) t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) -> ('a option, 'e) t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b option, 'e) t) -> ('b option, 'e) t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) ->
('a Core_kernel.Std.Sequence.t, 'e) t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b option, 'e) t) ->
('b Core_kernel.Std.Sequence.t, 'e) t
end
val ( >=> ) :
('a -> ('b, 'e) t) ->
('b -> ('c, 'e) t) -> 'a -> ('c, 'e) t
val ( !! ) : 'a -> ('a, 'e) t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val bind :
('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val both :
('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
end
val bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val return : 'a -> ('a, 'b) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore :
(Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
module Syntax :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
val ( >=> ) :
('a -> ('b, 'e) t) ->
('b -> ('c, 'e) t) -> 'a -> ('c, 'e) t
val ( !! ) : 'a -> ('a, 'e) t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
end
val pure : 'a -> ('a, 'e) t
val accept : 'a -> ('a, 'e) t
val reject : Monoid.Unit.t -> ('a, 'e) t
val guard : bool -> (Monoid.Unit.t, 'e) t
val on :
bool -> (Monoid.Unit.t, 'e) t -> (Monoid.Unit.t, 'e) t
val unless :
bool -> (Monoid.Unit.t, 'e) t -> (Monoid.Unit.t, 'e) t
val zero : Monoid.Unit.t -> ('a, 'e) t
val plus : ('a, 'e) t -> ('a, 'e) t -> ('a, 'e) t
type 'a error = Monoid.Unit.t
val fail : Monoid.Unit.t -> ('a, 'e) t
val catch :
('a, 'e) t -> (Monoid.Unit.t -> ('a, 'e) t) -> ('a, 'e) t
end
type 'a t = 'a option
type 'a m = 'a
type 'a e = 'a t
val lift : 'a -> 'a e
val run : 'a e -> 'a e
val void : 'a e -> Monoid.Unit.t e
val sequence : Monoid.Unit.t e list -> Monoid.Unit.t e
val forever : 'a e -> 'b e
module Fn :
sig
val id : 'a -> 'a e
val ignore : 'a e -> Monoid.Unit.t e
val nothing : Monoid.Unit.t -> Monoid.Unit.t e
val non : ('a -> bool e) -> 'a -> bool e
val apply_n_times :
n:Monoid.Int.t -> ('a -> 'a e) -> 'a -> 'a e
val compose : ('b -> 'c e) -> ('a -> 'b e) -> 'a -> 'c e
end
module Pair :
sig
val fst : ('a * 'b) e -> 'a e
val snd : ('a * 'b) e -> 'b e
end
module Triple :
sig
val fst : ('a * 'b * 'c) e -> 'a e
val snd : ('a * 'b * 'c) e -> 'b e
val trd : ('a * 'b * 'c) e -> 'c e
end
module Lift :
sig
val nullary : 'a -> 'a e
val unary : ('a -> 'b) -> 'a e -> 'b e
val binary : ('a -> 'b -> 'c) -> 'a e -> 'b e -> 'c e
val ternary :
('a -> 'b -> 'c -> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a e -> 'b e -> 'c e -> 'd e -> 'e e
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t e) ->
f:(Monoid.Unit.t -> 'a e) -> catch:(exn -> 'a e) -> 'a e
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a e t -> 'a t e
val all_ignore : 'a e t -> Monoid.Unit.t e
val sequence : Monoid.Unit.t e t -> Monoid.Unit.t e
val map : 'a t -> f:('a -> 'b e) -> 'b t e
val iter :
'a t -> f:('a -> Monoid.Unit.t e) -> Monoid.Unit.t e
val fold :
'a t -> init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_left :
'a t -> init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_right :
'a t -> f:('a -> 'b -> 'b e) -> init:'b -> 'b e
val reduce : 'a t -> f:('a -> 'a -> 'a e) -> 'a e e
val exists : 'a t -> f:('a -> bool e) -> bool e
val for_all : 'a t -> f:('a -> bool e) -> bool e
val count : 'a t -> f:('a -> bool e) -> Monoid.Int.t e
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> 'a e) -> 'a e
val find : 'a t -> f:('a -> bool e) -> 'a e e
val find_map : 'a t -> f:('a -> 'b e e) -> 'b e e
val filter : 'a t -> f:('a -> bool e) -> 'a t e
val filter_map : 'a t -> f:('a -> 'b e e) -> 'b t e
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : 'a e T.t -> 'a T.t e
val all_ignore : 'a e T.t -> Monoid.Unit.t e
val sequence : Monoid.Unit.t e T.t -> Monoid.Unit.t e
val map : 'a T.t -> f:('a -> 'b e) -> 'b T.t e
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t e) -> Monoid.Unit.t e
val fold :
'a T.t -> init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_left :
'a T.t -> init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_right :
'a T.t -> f:('a -> 'b -> 'b e) -> init:'b -> 'b e
val reduce : 'a T.t -> f:('a -> 'a -> 'a e) -> 'a e e
val exists : 'a T.t -> f:('a -> bool e) -> bool e
val for_all : 'a T.t -> f:('a -> bool e) -> bool e
val count :
'a T.t -> f:('a -> bool e) -> Monoid.Int.t e
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a e) -> 'a e
val find : 'a T.t -> f:('a -> bool e) -> 'a e e
val find_map : 'a T.t -> f:('a -> 'b e e) -> 'b e e
val filter : 'a T.t -> f:('a -> bool e) -> 'a T.t e
val filter_map :
'a T.t -> f:('a -> 'b e e) -> 'b T.t e
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : 'a e T.t -> 'a T.t e
val all_ignore : 'a e T.t -> Monoid.Unit.t e
val sequence : Monoid.Unit.t e T.t -> Monoid.Unit.t e
val map : 'a T.t -> f:('a -> 'b e) -> 'b T.t e
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t e) -> Monoid.Unit.t e
val fold :
'a T.t -> init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_left :
'a T.t -> init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_right :
'a T.t -> f:('a -> 'b -> 'b e) -> init:'b -> 'b e
val reduce : 'a T.t -> f:('a -> 'a -> 'a e) -> 'a e e
val exists : 'a T.t -> f:('a -> bool e) -> bool e
val for_all : 'a T.t -> f:('a -> bool e) -> bool e
val count :
'a T.t -> f:('a -> bool e) -> Monoid.Int.t e
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a e) -> 'a e
val find : 'a T.t -> f:('a -> bool e) -> 'a e e
val find_map : 'a T.t -> f:('a -> 'b e e) -> 'b e e
val filter : 'a T.t -> f:('a -> bool e) -> 'a T.t e
val filter_map :
'a T.t -> f:('a -> 'b e e) -> 'b T.t e
end
end
module List :
sig
val all : 'a e list -> 'a list e
val all_ignore : 'a e list -> Monoid.Unit.t e
val sequence : Monoid.Unit.t e list -> Monoid.Unit.t e
val map : 'a list -> f:('a -> 'b e) -> 'b list e
val iter :
'a list -> f:('a -> Monoid.Unit.t e) -> Monoid.Unit.t e
val fold :
'a list -> init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_left :
'a list -> init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_right :
'a list -> f:('a -> 'b -> 'b e) -> init:'b -> 'b e
val reduce : 'a list -> f:('a -> 'a -> 'a e) -> 'a e e
val exists : 'a list -> f:('a -> bool e) -> bool e
val for_all : 'a list -> f:('a -> bool e) -> bool e
val count : 'a list -> f:('a -> bool e) -> Monoid.Int.t e
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list -> f:('b -> 'a e) -> 'a e
val find : 'a list -> f:('a -> bool e) -> 'a e e
val find_map : 'a list -> f:('a -> 'b e e) -> 'b e e
val filter : 'a list -> f:('a -> bool e) -> 'a list e
val filter_map : 'a list -> f:('a -> 'b e e) -> 'b list e
end
module Seq :
sig
val all :
'a e Core_kernel.Std.Sequence.t ->
'a Core_kernel.Std.Sequence.t e
val all_ignore :
'a e Core_kernel.Std.Sequence.t -> Monoid.Unit.t e
val sequence :
Monoid.Unit.t e Core_kernel.Std.Sequence.t ->
Monoid.Unit.t e
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b e) -> 'b Core_kernel.Std.Sequence.t e
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> Monoid.Unit.t e) -> Monoid.Unit.t e
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> 'b e) -> init:'b -> 'b e
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> 'a e) -> 'a e e
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool e) -> bool e
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool e) -> bool e
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool e) -> Monoid.Int.t e
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t -> f:('b -> 'a e) -> 'a e
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool e) -> 'a e e
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b e e) -> 'b e e
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool e) -> 'a Core_kernel.Std.Sequence.t e
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b e e) -> 'b Core_kernel.Std.Sequence.t e
end
val ( >=> ) : ('a -> 'b e) -> ('b -> 'c e) -> 'a -> 'c e
val ( !! ) : 'a -> 'a e
val ( !$ ) : ('a -> 'b) -> 'a e -> 'b e
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a e -> 'b e -> 'c e
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a e -> 'b e -> 'c e -> 'd e -> 'e e
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
val ( >>= ) : 'a e -> ('a -> 'b e) -> 'b e
val ( >>| ) : 'a e -> ('a -> 'b) -> 'b e
module Monad_infix :
sig
val ( >>= ) : 'a e -> ('a -> 'b e) -> 'b e
val ( >>| ) : 'a e -> ('a -> 'b) -> 'b e
end
val bind : 'a e -> f:('a -> 'b e) -> 'b e
val return : 'a -> 'a e
val map : 'a e -> f:('a -> 'b) -> 'b e
val join : 'a e e -> 'a e
val ignore_m : 'a e -> Monoid.Unit.t e
val all : 'a e list -> 'a list e
val all_ignore : Monoid.Unit.t e list -> Monoid.Unit.t e
module Let_syntax :
sig
val return : 'a -> 'a e
val ( >>= ) : 'a e -> ('a -> 'b e) -> 'b e
val ( >>| ) : 'a e -> ('a -> 'b) -> 'b e
module Let_syntax :
sig
val return : 'a -> 'a e
val bind : 'a e -> f:('a -> 'b e) -> 'b e
val map : 'a e -> f:('a -> 'b) -> 'b e
val both : 'a e -> 'b e -> ('a * 'b) e
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) : 'a e -> ('a -> 'b e) -> 'b e
val ( >>| ) : 'a e -> ('a -> 'b) -> 'b e
val ( >=> ) : ('a -> 'b e) -> ('b -> 'c e) -> 'a -> 'c e
val ( !! ) : 'a -> 'a e
val ( !$ ) : ('a -> 'b) -> 'a e -> 'b e
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a e -> 'b e -> 'c e
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a e -> 'b e -> 'c e -> 'd e -> 'e e
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
end
val pure : 'a -> 'a e
val accept : 'a -> 'a e
val reject : Monoid.Unit.t -> 'a e
val guard : bool -> Monoid.Unit.t e
val on : bool -> Monoid.Unit.t e -> Monoid.Unit.t e
val unless : bool -> Monoid.Unit.t e -> Monoid.Unit.t e
val zero : Monoid.Unit.t -> 'a e
val plus : 'a e -> 'a e -> 'a e
type 'a error = Monoid.Unit.t
val fail : Monoid.Unit.t -> 'a e
val catch : 'a e -> (Monoid.Unit.t -> 'a e) -> 'a e
module T1 :
functor (M : Core_kernel.Std.T1) ->
sig
type 'a t = 'a e M.t
type 'a m = 'a M.t
type 'a e = 'a Monads.Std.Monad.Option.T1.t
end
module T2 :
functor (M : Core_kernel.Std.T2) ->
sig
type ('a, 'e) t = ('a e, 'e) M.t
type ('a, 'e) m = ('a, 'e) M.t
type ('a, 'e) e = ('a, 'e) Monads.Std.Monad.Option.T2.t
end
module Make :
functor (M : Monad) ->
sig
val lift : 'a M.t -> 'a T1(M).t
val run : 'a T1(M).t -> 'a Monads.Std.Monad.Option.T1.t
val void : 'a T1(M).t -> Monoid.Unit.t T1(M).t
val sequence :
Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
val forever : 'a T1(M).t -> 'b T1(M).t
module Fn :
sig
val id : 'a -> 'a T1(M).t
val ignore : 'a T1(M).t -> Monoid.Unit.t T1(M).t
val nothing : Monoid.Unit.t -> Monoid.Unit.t T1(M).t
val non : ('a -> bool T1(M).t) -> 'a -> bool T1(M).t
val apply_n_times :
n:Monoid.Int.t ->
('a -> 'a T1(M).t) -> 'a -> 'a T1(M).t
val compose :
('b -> 'c T1(M).t) ->
('a -> 'b T1(M).t) -> 'a -> 'c T1(M).t
end
module Pair :
sig
val fst : ('a * 'b) T1(M).t -> 'a T1(M).t
val snd : ('a * 'b) T1(M).t -> 'b T1(M).t
end
module Triple :
sig
val fst : ('a * 'b * 'c) T1(M).t -> 'a T1(M).t
val snd : ('a * 'b * 'c) T1(M).t -> 'b T1(M).t
val trd : ('a * 'b * 'c) T1(M).t -> 'c T1(M).t
end
module Lift :
sig
val nullary : 'a -> 'a T1(M).t
val unary : ('a -> 'b) -> 'a T1(M).t -> 'b T1(M).t
val binary :
('a -> 'b -> 'c) ->
'a T1(M).t -> 'b T1(M).t -> 'c T1(M).t
val ternary :
('a -> 'b -> 'c -> 'd) ->
'a T1(M).t ->
'b T1(M).t -> 'c T1(M).t -> 'd T1(M).t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(M).t ->
'b T1(M).t ->
'c T1(M).t -> 'd T1(M).t -> 'e T1(M).t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(M).t ->
'b T1(M).t ->
'c T1(M).t ->
'd T1(M).t -> 'e T1(M).t -> 'f T1(M).t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t T1(M).t) ->
f:(Monoid.Unit.t -> 'a T1(M).t) ->
catch:(exn -> 'a T1(M).t) -> 'a T1(M).t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a T1(M).t t -> 'a t T1(M).t
val all_ignore :
'a T1(M).t t -> Monoid.Unit.t T1(M).t
val sequence :
Monoid.Unit.t T1(M).t t ->
Monoid.Unit.t T1(M).t
val map :
'a t -> f:('a -> 'b T1(M).t) -> 'b t T1(M).t
val iter :
'a t ->
f:('a -> Monoid.Unit.t T1(M).t) ->
Monoid.Unit.t T1(M).t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_right :
'a t ->
f:('a -> 'b -> 'b T1(M).t) ->
init:'b -> 'b T1(M).t
val reduce :
'a t ->
f:('a -> 'a -> 'a T1(M).t) -> 'a e T1(M).t
val exists :
'a t -> f:('a -> bool T1(M).t) -> bool T1(M).t
val for_all :
'a t -> f:('a -> bool T1(M).t) -> bool T1(M).t
val count :
'a t ->
f:('a -> bool T1(M).t) -> Monoid.Int.t T1(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> 'a T1(M).t) -> 'a T1(M).t
val find :
'a t -> f:('a -> bool T1(M).t) -> 'a e T1(M).t
val find_map :
'a t -> f:('a -> 'b e T1(M).t) -> 'b e T1(M).t
val filter :
'a t -> f:('a -> bool T1(M).t) -> 'a t T1(M).t
val filter_map :
'a t -> f:('a -> 'b e T1(M).t) -> 'b t T1(M).t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : 'a T1(M).t T.t -> 'a T.t T1(M).t
val all_ignore :
'a T1(M).t T.t -> Monoid.Unit.t T1(M).t
val sequence :
Monoid.Unit.t T1(M).t T.t ->
Monoid.Unit.t T1(M).t
val map :
'a T.t ->
f:('a -> 'b T1(M).t) -> 'b T.t T1(M).t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t T1(M).t) ->
Monoid.Unit.t T1(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b T1(M).t) ->
init:'b -> 'b T1(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> 'a T1(M).t) -> 'a e T1(M).t
val exists :
'a T.t ->
f:('a -> bool T1(M).t) -> bool T1(M).t
val for_all :
'a T.t ->
f:('a -> bool T1(M).t) -> bool T1(M).t
val count :
'a T.t ->
f:('a -> bool T1(M).t) ->
Monoid.Int.t T1(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a T1(M).t) -> 'a T1(M).t
val find :
'a T.t ->
f:('a -> bool T1(M).t) -> 'a e T1(M).t
val find_map :
'a T.t ->
f:('a -> 'b e T1(M).t) -> 'b e T1(M).t
val filter :
'a T.t ->
f:('a -> bool T1(M).t) -> 'a T.t T1(M).t
val filter_map :
'a T.t ->
f:('a -> 'b e T1(M).t) -> 'b T.t T1(M).t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : 'a T1(M).t T.t -> 'a T.t T1(M).t
val all_ignore :
'a T1(M).t T.t -> Monoid.Unit.t T1(M).t
val sequence :
Monoid.Unit.t T1(M).t T.t ->
Monoid.Unit.t T1(M).t
val map :
'a T.t ->
f:('a -> 'b T1(M).t) -> 'b T.t T1(M).t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t T1(M).t) ->
Monoid.Unit.t T1(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b T1(M).t) ->
init:'b -> 'b T1(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> 'a T1(M).t) -> 'a e T1(M).t
val exists :
'a T.t ->
f:('a -> bool T1(M).t) -> bool T1(M).t
val for_all :
'a T.t ->
f:('a -> bool T1(M).t) -> bool T1(M).t
val count :
'a T.t ->
f:('a -> bool T1(M).t) ->
Monoid.Int.t T1(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a T1(M).t) -> 'a T1(M).t
val find :
'a T.t ->
f:('a -> bool T1(M).t) -> 'a e T1(M).t
val find_map :
'a T.t ->
f:('a -> 'b e T1(M).t) -> 'b e T1(M).t
val filter :
'a T.t ->
f:('a -> bool T1(M).t) -> 'a T.t T1(M).t
val filter_map :
'a T.t ->
f:('a -> 'b e T1(M).t) -> 'b T.t T1(M).t
end
end
module List :
sig
val all : 'a T1(M).t list -> 'a list T1(M).t
val all_ignore :
'a T1(M).t list -> Monoid.Unit.t T1(M).t
val sequence :
Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
val map :
'a list -> f:('a -> 'b T1(M).t) -> 'b list T1(M).t
val iter :
'a list ->
f:('a -> Monoid.Unit.t T1(M).t) ->
Monoid.Unit.t T1(M).t
val fold :
'a list ->
init:'b -> f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_left :
'a list ->
init:'b -> f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_right :
'a list ->
f:('a -> 'b -> 'b T1(M).t) -> init:'b -> 'b T1(M).t
val reduce :
'a list ->
f:('a -> 'a -> 'a T1(M).t) -> 'a e T1(M).t
val exists :
'a list -> f:('a -> bool T1(M).t) -> bool T1(M).t
val for_all :
'a list -> f:('a -> bool T1(M).t) -> bool T1(M).t
val count :
'a list ->
f:('a -> bool T1(M).t) -> Monoid.Int.t T1(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list -> f:('b -> 'a T1(M).t) -> 'a T1(M).t
val find :
'a list -> f:('a -> bool T1(M).t) -> 'a e T1(M).t
val find_map :
'a list -> f:('a -> 'b e T1(M).t) -> 'b e T1(M).t
val filter :
'a list ->
f:('a -> bool T1(M).t) -> 'a list T1(M).t
val filter_map :
'a list ->
f:('a -> 'b e T1(M).t) -> 'b list T1(M).t
end
module Seq :
sig
val all :
'a T1(M).t Core_kernel.Std.Sequence.t ->
'a Core_kernel.Std.Sequence.t T1(M).t
val all_ignore :
'a T1(M).t Core_kernel.Std.Sequence.t ->
Monoid.Unit.t T1(M).t
val sequence :
Monoid.Unit.t T1(M).t Core_kernel.Std.Sequence.t ->
Monoid.Unit.t T1(M).t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b T1(M).t) ->
'b Core_kernel.Std.Sequence.t T1(M).t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> Monoid.Unit.t T1(M).t) ->
Monoid.Unit.t T1(M).t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> 'b T1(M).t) -> init:'b -> 'b T1(M).t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> 'a T1(M).t) -> 'a e T1(M).t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(M).t) -> bool T1(M).t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(M).t) -> bool T1(M).t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(M).t) -> Monoid.Int.t T1(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> 'a T1(M).t) -> 'a T1(M).t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(M).t) -> 'a e T1(M).t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b e T1(M).t) -> 'b e T1(M).t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(M).t) ->
'a Core_kernel.Std.Sequence.t T1(M).t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b e T1(M).t) ->
'b Core_kernel.Std.Sequence.t T1(M).t
end
val ( >=> ) :
('a -> 'b T1(M).t) ->
('b -> 'c T1(M).t) -> 'a -> 'c T1(M).t
val ( !! ) : 'a -> 'a T1(M).t
val ( !$ ) : ('a -> 'b) -> 'a T1(M).t -> 'b T1(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
'a T1(M).t -> 'b T1(M).t -> 'c T1(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a T1(M).t -> 'b T1(M).t -> 'c T1(M).t -> 'd T1(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(M).t ->
'b T1(M).t -> 'c T1(M).t -> 'd T1(M).t -> 'e T1(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(M).t ->
'b T1(M).t ->
'c T1(M).t -> 'd T1(M).t -> 'e T1(M).t -> 'f T1(M).t
val ( >>= ) :
'a T1(M).t -> ('a -> 'b T1(M).t) -> 'b T1(M).t
val ( >>| ) : 'a T1(M).t -> ('a -> 'b) -> 'b T1(M).t
module Monad_infix :
sig
val ( >>= ) :
'a T1(M).t -> ('a -> 'b T1(M).t) -> 'b T1(M).t
val ( >>| ) : 'a T1(M).t -> ('a -> 'b) -> 'b T1(M).t
end
val bind :
'a T1(M).t -> f:('a -> 'b T1(M).t) -> 'b T1(M).t
val return : 'a -> 'a T1(M).t
val map : 'a T1(M).t -> f:('a -> 'b) -> 'b T1(M).t
val join : 'a T1(M).t T1(M).t -> 'a T1(M).t
val ignore_m : 'a T1(M).t -> Monoid.Unit.t T1(M).t
val all : 'a T1(M).t list -> 'a list T1(M).t
val all_ignore :
Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
module Let_syntax :
sig
val return : 'a -> 'a T1(M).t
val ( >>= ) :
'a T1(M).t -> ('a -> 'b T1(M).t) -> 'b T1(M).t
val ( >>| ) : 'a T1(M).t -> ('a -> 'b) -> 'b T1(M).t
module Let_syntax :
sig
val return : 'a -> 'a T1(M).t
val bind :
'a T1(M).t ->
f:('a -> 'b T1(M).t) -> 'b T1(M).t
val map :
'a T1(M).t -> f:('a -> 'b) -> 'b T1(M).t
val both :
'a T1(M).t -> 'b T1(M).t -> ('a * 'b) T1(M).t
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) :
'a T1(M).t -> ('a -> 'b T1(M).t) -> 'b T1(M).t
val ( >>| ) : 'a T1(M).t -> ('a -> 'b) -> 'b T1(M).t
val ( >=> ) :
('a -> 'b T1(M).t) ->
('b -> 'c T1(M).t) -> 'a -> 'c T1(M).t
val ( !! ) : 'a -> 'a T1(M).t
val ( !$ ) : ('a -> 'b) -> 'a T1(M).t -> 'b T1(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
'a T1(M).t -> 'b T1(M).t -> 'c T1(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a T1(M).t ->
'b T1(M).t -> 'c T1(M).t -> 'd T1(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(M).t ->
'b T1(M).t ->
'c T1(M).t -> 'd T1(M).t -> 'e T1(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(M).t ->
'b T1(M).t ->
'c T1(M).t ->
'd T1(M).t -> 'e T1(M).t -> 'f T1(M).t
end
val pure : 'a -> 'a T1(M).t
val accept : 'a -> 'a T1(M).t
val reject : Monoid.Unit.t -> 'a T1(M).t
val guard : bool -> Monoid.Unit.t T1(M).t
val on :
bool -> Monoid.Unit.t T1(M).t -> Monoid.Unit.t T1(M).t
val unless :
bool -> Monoid.Unit.t T1(M).t -> Monoid.Unit.t T1(M).t
val zero : Monoid.Unit.t -> 'a T1(M).t
val plus : 'a T1(M).t -> 'a T1(M).t -> 'a T1(M).t
type 'a error = Monoid.Unit.t
val fail : Monoid.Unit.t -> 'a T1(M).t
val catch :
'a T1(M).t ->
(Monoid.Unit.t -> 'a T1(M).t) -> 'a T1(M).t
end
module Make2 :
functor (M : Monad2) ->
sig
val lift : ('a, 'e) M.t -> ('a, 'e) T2(M).t
val run :
('a, 'e) T2(M).t ->
('a, 'e) Monads.Std.Monad.Option.T2.t
val void :
('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
module Fn :
sig
val id : 'a -> ('a, 'e) T2(M).t
val ignore :
('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
val nothing :
Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
val non :
('a -> (bool, 'e) T2(M).t) ->
'a -> (bool, 'e) T2(M).t
val apply_n_times :
n:Monoid.Int.t ->
('a -> ('a, 'e) T2(M).t) -> 'a -> ('a, 'e) T2(M).t
val compose :
('b -> ('c, 'e) T2(M).t) ->
('a -> ('b, 'e) T2(M).t) -> 'a -> ('c, 'e) T2(M).t
end
module Pair :
sig
val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
end
module Triple :
sig
val fst :
('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
val snd :
('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
val trd :
('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
end
module Lift :
sig
val nullary : 'a -> ('a, 'e) T2(M).t
val unary :
('a -> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
val binary :
('a -> 'b -> 'c) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
val ternary :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t ->
('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t -> ('e, 's) T2(M).t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t ->
('e, 's) T2(M).t -> ('f, 's) T2(M).t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t ->
(Monoid.Unit.t, 's) T2(M).t) ->
f:(Monoid.Unit.t -> ('a, 's) T2(M).t) ->
catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
end
module Collection :
sig
module type S =
sig
type 'a t
val all :
('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b t, 'e) T2(M).t
val iter :
'a t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a e, 'e) T2(M).t
val exists :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val for_all :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val count :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t ->
f:('b -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
val find :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a e, 'e) T2(M).t
val find_map :
'a t ->
f:('a -> ('b e, 'e) T2(M).t) ->
('b e, 'e) T2(M).t
val filter :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a t, 'e) T2(M).t
val filter_map :
'a t ->
f:('a -> ('b e, 'e) T2(M).t) ->
('b t, 'e) T2(M).t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all :
('a, 'e) T2(M).t T.t -> ('a T.t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a T.t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a e, 'e) T2(M).t
val exists :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val count :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> ('a, 'e) T2(M).t) ->
('a, 'e) T2(M).t
val find :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a e, 'e) T2(M).t
val find_map :
'a T.t ->
f:('a -> ('b e, 'e) T2(M).t) ->
('b e, 'e) T2(M).t
val filter :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a T.t, 'e) T2(M).t
val filter_map :
'a T.t ->
f:('a -> ('b e, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all :
('a, 'e) T2(M).t T.t -> ('a T.t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a T.t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a e, 'e) T2(M).t
val exists :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val count :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> ('a, 'e) T2(M).t) ->
('a, 'e) T2(M).t
val find :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a e, 'e) T2(M).t
val find_map :
'a T.t ->
f:('a -> ('b e, 'e) T2(M).t) ->
('b e, 'e) T2(M).t
val filter :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a T.t, 'e) T2(M).t
val filter_map :
'a T.t ->
f:('a -> ('b e, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
end
end
module List :
sig
val all :
('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a list ->
f:('a -> ('b, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
val iter :
'a list ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a list ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a list ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a list ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a list ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a e, 'e) T2(M).t
val exists :
'a list ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val for_all :
'a list ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val count :
'a list ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list ->
f:('b -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
val find :
'a list ->
f:('a -> (bool, 'e) T2(M).t) -> ('a e, 'e) T2(M).t
val find_map :
'a list ->
f:('a -> ('b e, 'e) T2(M).t) -> ('b e, 'e) T2(M).t
val filter :
'a list ->
f:('a -> (bool, 'e) T2(M).t) ->
('a list, 'e) T2(M).t
val filter_map :
'a list ->
f:('a -> ('b e, 'e) T2(M).t) ->
('b list, 'e) T2(M).t
end
module Seq :
sig
val all :
('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
('a Core_kernel.Std.Sequence.t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t
Core_kernel.Std.Sequence.t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b Core_kernel.Std.Sequence.t, 'e) T2(M).t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a e, 'e) T2(M).t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) -> ('a e, 'e) T2(M).t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b e, 'e) T2(M).t) -> ('b e, 'e) T2(M).t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Core_kernel.Std.Sequence.t, 'e) T2(M).t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b e, 'e) T2(M).t) ->
('b Core_kernel.Std.Sequence.t, 'e) T2(M).t
end
val ( >=> ) :
('a -> ('b, 'e) T2(M).t) ->
('b -> ('c, 'e) T2(M).t) -> 'a -> ('c, 'e) T2(M).t
val ( !! ) : 'a -> ('a, 'e) T2(M).t
val ( !$ ) :
('a -> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t ->
('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t -> ('e, 's) T2(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t ->
('e, 's) T2(M).t -> ('f, 's) T2(M).t
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) T2(M).t
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) T2(M).t
val bind :
('a, 'e) T2(M).t ->
f:('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val map :
('a, 'e) T2(M).t ->
f:('a -> 'b) -> ('b, 'e) T2(M).t
val both :
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
end
val bind :
('a, 'e) T2(M).t ->
f:('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val return : 'a -> ('a, 'b) T2(M).t
val map :
('a, 'e) T2(M).t -> f:('a -> 'b) -> ('b, 'e) T2(M).t
val join :
(('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
val ignore_m :
('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
val all_ignore :
(Monoid.Unit.t, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
module Syntax :
sig
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
val ( >=> ) :
('a -> ('b, 'e) T2(M).t) ->
('b -> ('c, 'e) T2(M).t) -> 'a -> ('c, 'e) T2(M).t
val ( !! ) : 'a -> ('a, 'e) T2(M).t
val ( !$ ) :
('a -> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t ->
('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t -> ('e, 's) T2(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t ->
('e, 's) T2(M).t -> ('f, 's) T2(M).t
end
val pure : 'a -> ('a, 'e) T2(M).t
val accept : 'a -> ('a, 'e) T2(M).t
val reject : Monoid.Unit.t -> ('a, 'e) T2(M).t
val guard : bool -> (Monoid.Unit.t, 'e) T2(M).t
val on :
bool ->
(Monoid.Unit.t, 'e) T2(M).t ->
(Monoid.Unit.t, 'e) T2(M).t
val unless :
bool ->
(Monoid.Unit.t, 'e) T2(M).t ->
(Monoid.Unit.t, 'e) T2(M).t
val zero : Monoid.Unit.t -> ('a, 'e) T2(M).t
val plus :
('a, 'e) T2(M).t ->
('a, 'e) T2(M).t -> ('a, 'e) T2(M).t
type 'a error = Monoid.Unit.t
val fail : Monoid.Unit.t -> ('a, 'e) T2(M).t
val catch :
('a, 'e) T2(M).t ->
(Monoid.Unit.t -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
end
end
module Result :
sig
type ('a, 'e) result =
('a, 'e) Core_kernel.Std.Result.t =
Ok of 'a
| Error of 'e
module type S =
sig
type err
type 'a t
type 'a m
type 'a e
val lift : 'a m -> 'a t
val run : 'a t -> 'a e
val void : 'a t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
val forever : 'a t -> 'b t
module Fn :
sig
val id : 'a -> 'a t
val ignore : 'a t -> Monoid.Unit.t t
val nothing : Monoid.Unit.t -> Monoid.Unit.t t
val non : ('a -> bool t) -> 'a -> bool t
val apply_n_times :
n:Monoid.Int.t -> ('a -> 'a t) -> 'a -> 'a t
val compose :
('b -> 'c t) -> ('a -> 'b t) -> 'a -> 'c t
end
module Pair :
sig
val fst : ('a * 'b) t -> 'a t
val snd : ('a * 'b) t -> 'b t
end
module Triple :
sig
val fst : ('a * 'b * 'c) t -> 'a t
val snd : ('a * 'b * 'c) t -> 'b t
val trd : ('a * 'b * 'c) t -> 'c t
end
module Lift :
sig
val nullary : 'a -> 'a t
val unary : ('a -> 'b) -> 'a t -> 'b t
val binary : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ternary :
('a -> 'b -> 'c -> 'd) ->
'a t -> 'b t -> 'c t -> 'd t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
f:(Monoid.Unit.t -> 'a t) ->
catch:(exn -> 'a t) -> 'a t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a t t -> 'a t t
val all_ignore : 'a t t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
val map : 'a t -> f:('a -> 'b t) -> 'b t t
val iter :
'a t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a t -> f:('a -> bool t) -> bool t
val for_all : 'a t -> f:('a -> bool t) -> bool t
val count :
'a t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> 'a t) -> 'a t
val find :
'a t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a t -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter : 'a t -> f:('a -> bool t) -> 'a t t
val filter_map :
'a t -> f:('a -> 'b Option.t t) -> 'b t t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a T.t -> f:('a -> bool t) -> bool t
val for_all :
'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a T.t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t -> f:('a -> 'b Option.t t) -> 'b T.t t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a T.t -> f:('a -> bool t) -> bool t
val for_all :
'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a T.t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t -> f:('a -> 'b Option.t t) -> 'b T.t t
end
end
module List :
sig
val all : 'a t list -> 'a list t
val all_ignore : 'a t list -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
val map : 'a list -> f:('a -> 'b t) -> 'b list t
val iter :
'a list ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a list -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a list -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a list -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a list -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a list -> f:('a -> bool t) -> bool t
val for_all : 'a list -> f:('a -> bool t) -> bool t
val count :
'a list -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list -> f:('b -> 'a t) -> 'a t
val find : 'a list -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a list -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter : 'a list -> f:('a -> bool t) -> 'a list t
val filter_map :
'a list -> f:('a -> 'b Option.t t) -> 'b list t
end
module Seq :
sig
val all :
'a t Core_kernel.Std.Sequence.t ->
'a Core_kernel.Std.Sequence.t t
val all_ignore :
'a t Core_kernel.Std.Sequence.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t Core_kernel.Std.Sequence.t ->
Monoid.Unit.t t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b t) -> 'b Core_kernel.Std.Sequence.t t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> bool t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> bool t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> 'a t) -> 'a t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> 'a Option.t t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> 'a Core_kernel.Std.Sequence.t t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b Option.t t) ->
'b Core_kernel.Std.Sequence.t t
end
val ( >=> ) : ('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Monad_infix :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
end
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val return : 'a -> 'a t
val map : 'a t -> f:('a -> 'b) -> 'b t
val join : 'a t t -> 'a t
val ignore_m : 'a t -> Monoid.Unit.t t
val all : 'a t list -> 'a list t
val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
module Let_syntax :
sig
val return : 'a -> 'a t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Let_syntax :
sig
val return : 'a -> 'a t
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val map : 'a t -> f:('a -> 'b) -> 'b t
val both : 'a t -> 'b t -> ('a * 'b) t
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
val ( >=> ) :
('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
type 'a error = err
val fail : err -> 'a t
val catch : 'a t -> (err -> 'a t) -> 'a t
end
module type S2 =
sig
type ('a, 'e) t
type 'a m
type ('a, 'e) e
val lift : 'a m -> ('a, 'e) t
val run : ('a, 'e) t -> ('a, 'e) e
val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
val forever : ('a, 'e) t -> ('b, 'e) t
module Fn :
sig
val id : 'a -> ('a, 'e) t
val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
val non : ('a -> (bool, 'e) t) -> 'a -> (bool, 'e) t
val apply_n_times :
n:Monoid.Int.t ->
('a -> ('a, 'e) t) -> 'a -> ('a, 'e) t
val compose :
('b -> ('c, 'e) t) ->
('a -> ('b, 'e) t) -> 'a -> ('c, 'e) t
end
module Pair :
sig
val fst : ('a * 'b, 'e) t -> ('a, 'e) t
val snd : ('a * 'b, 'e) t -> ('b, 'e) t
end
module Triple :
sig
val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
end
module Lift :
sig
val nullary : 'a -> ('a, 'e) t
val unary : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val binary :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ternary :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
f:(Monoid.Unit.t -> ('a, 's) t) ->
catch:(exn -> ('a, 's) t) -> ('a, 's) t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : ('a, 'e) t t -> ('a t, 'e) t
val all_ignore :
('a, 'e) t t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
val map :
'a t -> f:('a -> ('b, 'e) t) -> ('b t, 'e) t
val iter :
'a t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a t -> f:('a -> (bool, 'e) t) -> ('a t, 'e) t
val filter_map :
'a t ->
f:('a -> ('b Option.t, 'e) t) -> ('b t, 'e) t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : ('a, 'e) t T.t -> ('a T.t, 'e) t
val all_ignore :
('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t T.t ->
(Monoid.Unit.t, 'e) t
val map :
'a T.t ->
f:('a -> ('b, 'e) t) -> ('b T.t, 'e) t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) t) ->
('a Option.t, 'e) t
val exists :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a T.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a T.t, 'e) t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b T.t, 'e) t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : ('a, 'e) t T.t -> ('a T.t, 'e) t
val all_ignore :
('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t T.t ->
(Monoid.Unit.t, 'e) t
val map :
'a T.t ->
f:('a -> ('b, 'e) t) -> ('b T.t, 'e) t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) t) ->
('a Option.t, 'e) t
val exists :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a T.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a T.t, 'e) t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b T.t, 'e) t
end
end
module List :
sig
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore :
('a, 'e) t list -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
val map :
'a list -> f:('a -> ('b, 'e) t) -> ('b list, 'e) t
val iter :
'a list ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a list ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a list ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a list ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a list ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a list -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a list -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a list ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a list ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a list ->
f:('a -> ('b Option.t, 'e) t) -> ('b Option.t, 'e) t
val filter :
'a list -> f:('a -> (bool, 'e) t) -> ('a list, 'e) t
val filter_map :
'a list ->
f:('a -> ('b Option.t, 'e) t) -> ('b list, 'e) t
end
module Seq :
sig
val all :
('a, 'e) t Core_kernel.Std.Sequence.t ->
('a Core_kernel.Std.Sequence.t, 'e) t
val all_ignore :
('a, 'e) t Core_kernel.Std.Sequence.t ->
(Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t Core_kernel.Std.Sequence.t ->
(Monoid.Unit.t, 'e) t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b, 'e) t) ->
('b Core_kernel.Std.Sequence.t, 'e) t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b Option.t, 'e) t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) ->
('a Core_kernel.Std.Sequence.t, 'e) t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Core_kernel.Std.Sequence.t, 'e) t
end
val ( >=> ) :
('a -> ('b, 'e) t) ->
('b -> ('c, 'e) t) -> 'a -> ('c, 'e) t
val ( !! ) : 'a -> ('a, 'e) t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val bind :
('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val both :
('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
end
val bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val return : 'a -> ('a, 'b) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore :
(Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
module Syntax :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
val ( >=> ) :
('a -> ('b, 'e) t) ->
('b -> ('c, 'e) t) -> 'a -> ('c, 'e) t
val ( !! ) : 'a -> ('a, 'e) t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
end
type 'a error = 'a
val fail : 'e -> ('a, 'e) t
val catch : ('a, 'e) t -> ('e -> ('a, 'e) t) -> ('a, 'e) t
end
module T1 :
functor (T : Core_kernel.Std.T) (M : Monad) ->
sig
type error = T.t
type 'a m = 'a M.t
type 'a t =
('a, Monads.Std.Monad.Result.T1.error)
Monads.Std.Monad.Result.result
Monads.Std.Monad.Result.T1.m
type 'a e =
('a, Monads.Std.Monad.Result.T1.error)
Monads.Std.Monad.Result.result
Monads.Std.Monad.Result.T1.m
end
module T2 :
functor (M : Monad) ->
sig
type 'a m = 'a M.t
type ('a, 'e) t =
('a, 'e) Monads.Std.Monad.Result.result
Monads.Std.Monad.Result.T2.m
type ('a, 'e) e =
('a, 'e) Monads.Std.Monad.Result.result
Monads.Std.Monad.Result.T2.m
end
module Make :
functor (T : Core_kernel.Std.T) (M : Monad) ->
sig
val lift : 'a M.t -> 'a T1(T)(M).t
val run : 'a T1(T)(M).t -> 'a T1(T)(M).e
val void : 'a T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t list ->
Monoid.Unit.t T1(T)(M).t
val forever : 'a T1(T)(M).t -> 'b T1(T)(M).t
module Fn :
sig
val id : 'a -> 'a T1(T)(M).t
val ignore :
'a T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
val nothing :
Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t
val non :
('a -> bool T1(T)(M).t) -> 'a -> bool T1(T)(M).t
val apply_n_times :
n:Monoid.Int.t ->
('a -> 'a T1(T)(M).t) -> 'a -> 'a T1(T)(M).t
val compose :
('b -> 'c T1(T)(M).t) ->
('a -> 'b T1(T)(M).t) -> 'a -> 'c T1(T)(M).t
end
module Pair :
sig
val fst : ('a * 'b) T1(T)(M).t -> 'a T1(T)(M).t
val snd : ('a * 'b) T1(T)(M).t -> 'b T1(T)(M).t
end
module Triple :
sig
val fst : ('a * 'b * 'c) T1(T)(M).t -> 'a T1(T)(M).t
val snd : ('a * 'b * 'c) T1(T)(M).t -> 'b T1(T)(M).t
val trd : ('a * 'b * 'c) T1(T)(M).t -> 'c T1(T)(M).t
end
module Lift :
sig
val nullary : 'a -> 'a T1(T)(M).t
val unary :
('a -> 'b) -> 'a T1(T)(M).t -> 'b T1(T)(M).t
val binary :
('a -> 'b -> 'c) ->
'a T1(T)(M).t -> 'b T1(T)(M).t -> 'c T1(T)(M).t
val ternary :
('a -> 'b -> 'c -> 'd) ->
'a T1(T)(M).t ->
'b T1(T)(M).t -> 'c T1(T)(M).t -> 'd T1(T)(M).t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t -> 'd T1(T)(M).t -> 'e T1(T)(M).t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t ->
'd T1(T)(M).t -> 'e T1(T)(M).t -> 'f T1(T)(M).t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t) ->
f:(Monoid.Unit.t -> 'a T1(T)(M).t) ->
catch:(exn -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a T1(T)(M).t t -> 'a t T1(T)(M).t
val all_ignore :
'a T1(T)(M).t t -> Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t t ->
Monoid.Unit.t T1(T)(M).t
val map :
'a t ->
f:('a -> 'b T1(T)(M).t) -> 'b t T1(T)(M).t
val iter :
'a t ->
f:('a -> Monoid.Unit.t T1(T)(M).t) ->
Monoid.Unit.t T1(T)(M).t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_right :
'a t ->
f:('a -> 'b -> 'b T1(T)(M).t) ->
init:'b -> 'b T1(T)(M).t
val reduce :
'a t ->
f:('a -> 'a -> 'a T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val exists :
'a t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val for_all :
'a t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val count :
'a t ->
f:('a -> bool T1(T)(M).t) ->
Monoid.Int.t T1(T)(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t ->
f:('b -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
val find :
'a t ->
f:('a -> bool T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val find_map :
'a t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Option.t T1(T)(M).t
val filter :
'a t ->
f:('a -> bool T1(T)(M).t) -> 'a t T1(T)(M).t
val filter_map :
'a t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b t T1(T)(M).t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all :
'a T1(T)(M).t T.t -> 'a T.t T1(T)(M).t
val all_ignore :
'a T1(T)(M).t T.t -> Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t T.t ->
Monoid.Unit.t T1(T)(M).t
val map :
'a T.t ->
f:('a -> 'b T1(T)(M).t) -> 'b T.t T1(T)(M).t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t T1(T)(M).t) ->
Monoid.Unit.t T1(T)(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) ->
'b T1(T)(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) ->
'b T1(T)(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b T1(T)(M).t) ->
init:'b -> 'b T1(T)(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> 'a T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val exists :
'a T.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val for_all :
'a T.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val count :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
Monoid.Int.t T1(T)(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
val find :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val find_map :
'a T.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Option.t T1(T)(M).t
val filter :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
'a T.t T1(T)(M).t
val filter_map :
'a T.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b T.t T1(T)(M).t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all :
'a T1(T)(M).t T.t -> 'a T.t T1(T)(M).t
val all_ignore :
'a T1(T)(M).t T.t -> Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t T.t ->
Monoid.Unit.t T1(T)(M).t
val map :
'a T.t ->
f:('a -> 'b T1(T)(M).t) -> 'b T.t T1(T)(M).t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t T1(T)(M).t) ->
Monoid.Unit.t T1(T)(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) ->
'b T1(T)(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) ->
'b T1(T)(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b T1(T)(M).t) ->
init:'b -> 'b T1(T)(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> 'a T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val exists :
'a T.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val for_all :
'a T.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val count :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
Monoid.Int.t T1(T)(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
val find :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val find_map :
'a T.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Option.t T1(T)(M).t
val filter :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
'a T.t T1(T)(M).t
val filter_map :
'a T.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b T.t T1(T)(M).t
end
end
module List :
sig
val all : 'a T1(T)(M).t list -> 'a list T1(T)(M).t
val all_ignore :
'a T1(T)(M).t list -> Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t list ->
Monoid.Unit.t T1(T)(M).t
val map :
'a list ->
f:('a -> 'b T1(T)(M).t) -> 'b list T1(T)(M).t
val iter :
'a list ->
f:('a -> Monoid.Unit.t T1(T)(M).t) ->
Monoid.Unit.t T1(T)(M).t
val fold :
'a list ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_left :
'a list ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_right :
'a list ->
f:('a -> 'b -> 'b T1(T)(M).t) ->
init:'b -> 'b T1(T)(M).t
val reduce :
'a list ->
f:('a -> 'a -> 'a T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val exists :
'a list ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val for_all :
'a list ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val count :
'a list ->
f:('a -> bool T1(T)(M).t) ->
Monoid.Int.t T1(T)(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list -> f:('b -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
val find :
'a list ->
f:('a -> bool T1(T)(M).t) -> 'a Option.t T1(T)(M).t
val find_map :
'a list ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Option.t T1(T)(M).t
val filter :
'a list ->
f:('a -> bool T1(T)(M).t) -> 'a list T1(T)(M).t
val filter_map :
'a list ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b list T1(T)(M).t
end
module Seq :
sig
val all :
'a T1(T)(M).t Core_kernel.Std.Sequence.t ->
'a Core_kernel.Std.Sequence.t T1(T)(M).t
val all_ignore :
'a T1(T)(M).t Core_kernel.Std.Sequence.t ->
Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t Core_kernel.Std.Sequence.t ->
Monoid.Unit.t T1(T)(M).t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b T1(T)(M).t) ->
'b Core_kernel.Std.Sequence.t T1(T)(M).t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> Monoid.Unit.t T1(T)(M).t) ->
Monoid.Unit.t T1(T)(M).t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> 'b T1(T)(M).t) ->
init:'b -> 'b T1(T)(M).t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> 'a T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(T)(M).t) ->
Monoid.Int.t T1(T)(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(T)(M).t) -> 'a Option.t T1(T)(M).t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Option.t T1(T)(M).t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(T)(M).t) ->
'a Core_kernel.Std.Sequence.t T1(T)(M).t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Core_kernel.Std.Sequence.t T1(T)(M).t
end
val ( >=> ) :
('a -> 'b T1(T)(M).t) ->
('b -> 'c T1(T)(M).t) -> 'a -> 'c T1(T)(M).t
val ( !! ) : 'a -> 'a T1(T)(M).t
val ( !$ ) : ('a -> 'b) -> 'a T1(T)(M).t -> 'b T1(T)(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
'a T1(T)(M).t -> 'b T1(T)(M).t -> 'c T1(T)(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a T1(T)(M).t ->
'b T1(T)(M).t -> 'c T1(T)(M).t -> 'd T1(T)(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t -> 'd T1(T)(M).t -> 'e T1(T)(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t ->
'd T1(T)(M).t -> 'e T1(T)(M).t -> 'f T1(T)(M).t
val ( >>= ) :
'a T1(T)(M).t -> ('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val ( >>| ) :
'a T1(T)(M).t -> ('a -> 'b) -> 'b T1(T)(M).t
module Monad_infix :
sig
val ( >>= ) :
'a T1(T)(M).t ->
('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val ( >>| ) :
'a T1(T)(M).t -> ('a -> 'b) -> 'b T1(T)(M).t
end
val bind :
'a T1(T)(M).t ->
f:('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val return : 'a -> 'a T1(T)(M).t
val map : 'a T1(T)(M).t -> f:('a -> 'b) -> 'b T1(T)(M).t
val join : 'a T1(T)(M).t T1(T)(M).t -> 'a T1(T)(M).t
val ignore_m : 'a T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
val all : 'a T1(T)(M).t list -> 'a list T1(T)(M).t
val all_ignore :
Monoid.Unit.t T1(T)(M).t list ->
Monoid.Unit.t T1(T)(M).t
module Let_syntax :
sig
val return : 'a -> 'a T1(T)(M).t
val ( >>= ) :
'a T1(T)(M).t ->
('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val ( >>| ) :
'a T1(T)(M).t -> ('a -> 'b) -> 'b T1(T)(M).t
module Let_syntax :
sig
val return : 'a -> 'a T1(T)(M).t
val bind :
'a T1(T)(M).t ->
f:('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val map :
'a T1(T)(M).t -> f:('a -> 'b) -> 'b T1(T)(M).t
val both :
'a T1(T)(M).t ->
'b T1(T)(M).t -> ('a * 'b) T1(T)(M).t
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) :
'a T1(T)(M).t ->
('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val ( >>| ) :
'a T1(T)(M).t -> ('a -> 'b) -> 'b T1(T)(M).t
val ( >=> ) :
('a -> 'b T1(T)(M).t) ->
('b -> 'c T1(T)(M).t) -> 'a -> 'c T1(T)(M).t
val ( !! ) : 'a -> 'a T1(T)(M).t
val ( !$ ) :
('a -> 'b) -> 'a T1(T)(M).t -> 'b T1(T)(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
'a T1(T)(M).t -> 'b T1(T)(M).t -> 'c T1(T)(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a T1(T)(M).t ->
'b T1(T)(M).t -> 'c T1(T)(M).t -> 'd T1(T)(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t -> 'd T1(T)(M).t -> 'e T1(T)(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t ->
'd T1(T)(M).t -> 'e T1(T)(M).t -> 'f T1(T)(M).t
end
type 'a error = T.t
val fail : T.t -> 'a T1(T)(M).t
val catch :
'a T1(T)(M).t ->
(T.t -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
end
module Make2 :
functor (M : Monad) ->
sig
val lift : 'a M.t -> ('a, 'e) T2(M).t
val run : ('a, 'e) T2(M).t -> ('a, 'e) T2(M).e
val void :
('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
module Fn :
sig
val id : 'a -> ('a, 'e) T2(M).t
val ignore :
('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
val nothing :
Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
val non :
('a -> (bool, 'e) T2(M).t) ->
'a -> (bool, 'e) T2(M).t
val apply_n_times :
n:Monoid.Int.t ->
('a -> ('a, 'e) T2(M).t) -> 'a -> ('a, 'e) T2(M).t
val compose :
('b -> ('c, 'e) T2(M).t) ->
('a -> ('b, 'e) T2(M).t) -> 'a -> ('c, 'e) T2(M).t
end
module Pair :
sig
val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
end
module Triple :
sig
val fst :
('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
val snd :
('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
val trd :
('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
end
module Lift :
sig
val nullary : 'a -> ('a, 'e) T2(M).t
val unary :
('a -> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
val binary :
('a -> 'b -> 'c) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
val ternary :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t ->
('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t -> ('e, 's) T2(M).t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t ->
('e, 's) T2(M).t -> ('f, 's) T2(M).t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t ->
(Monoid.Unit.t, 's) T2(M).t) ->
f:(Monoid.Unit.t -> ('a, 's) T2(M).t) ->
catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
end
module Collection :
sig
module type S =
sig
type 'a t
val all :
('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b t, 'e) T2(M).t
val iter :
'a t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val for_all :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val count :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t ->
f:('b -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
val find :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a t, 'e) T2(M).t
val filter_map :
'a t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b t, 'e) T2(M).t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all :
('a, 'e) T2(M).t T.t -> ('a T.t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a T.t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val count :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> ('a, 'e) T2(M).t) ->
('a, 'e) T2(M).t
val find :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a T.t, 'e) T2(M).t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all :
('a, 'e) T2(M).t T.t -> ('a T.t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a T.t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val count :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> ('a, 'e) T2(M).t) ->
('a, 'e) T2(M).t
val find :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a T.t, 'e) T2(M).t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
end
end
module List :
sig
val all :
('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a list ->
f:('a -> ('b, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
val iter :
'a list ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a list ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a list ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a list ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a list ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a list ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val for_all :
'a list ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val count :
'a list ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list ->
f:('b -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
val find :
'a list ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a list ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a list ->
f:('a -> (bool, 'e) T2(M).t) ->
('a list, 'e) T2(M).t
val filter_map :
'a list ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b list, 'e) T2(M).t
end
module Seq :
sig
val all :
('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
('a Core_kernel.Std.Sequence.t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t
Core_kernel.Std.Sequence.t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b Core_kernel.Std.Sequence.t, 'e) T2(M).t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Core_kernel.Std.Sequence.t, 'e) T2(M).t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Core_kernel.Std.Sequence.t, 'e) T2(M).t
end
val ( >=> ) :
('a -> ('b, 'e) T2(M).t) ->
('b -> ('c, 'e) T2(M).t) -> 'a -> ('c, 'e) T2(M).t
val ( !! ) : 'a -> ('a, 'e) T2(M).t
val ( !$ ) :
('a -> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t ->
('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t -> ('e, 's) T2(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t ->
('e, 's) T2(M).t -> ('f, 's) T2(M).t
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) T2(M).t
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) T2(M).t
val bind :
('a, 'e) T2(M).t ->
f:('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val map :
('a, 'e) T2(M).t ->
f:('a -> 'b) -> ('b, 'e) T2(M).t
val both :
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
end
val bind :
('a, 'e) T2(M).t ->
f:('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val return : 'a -> ('a, 'b) T2(M).t
val map :
('a, 'e) T2(M).t -> f:('a -> 'b) -> ('b, 'e) T2(M).t
val join :
(('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
val ignore_m :
('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
val all_ignore :
(Monoid.Unit.t, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
module Syntax :
sig
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
val ( >=> ) :
('a -> ('b, 'e) T2(M).t) ->
('b -> ('c, 'e) T2(M).t) -> 'a -> ('c, 'e) T2(M).t
val ( !! ) : 'a -> ('a, 'e) T2(M).t
val ( !$ ) :
('a -> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t ->
('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t -> ('e, 's) T2(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t ->
('e, 's) T2(M).t -> ('f, 's) T2(M).t
end
type 'a error = 'a
val fail : 'e -> ('a, 'e) T2(M).t
val catch :
('a, 'e) T2(M).t ->
('e -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
end
module Error :
sig
module type S =
sig
type err
type 'a t
type 'a m
type 'a e
val lift : 'a m -> 'a t
val run : 'a t -> 'a e
val void : 'a t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
val forever : 'a t -> 'b t
module Fn :
sig
val id : 'a -> 'a t
val ignore : 'a t -> Monoid.Unit.t t
val nothing : Monoid.Unit.t -> Monoid.Unit.t t
val non : ('a -> bool t) -> 'a -> bool t
val apply_n_times :
n:Monoid.Int.t -> ('a -> 'a t) -> 'a -> 'a t
val compose :
('b -> 'c t) -> ('a -> 'b t) -> 'a -> 'c t
end
module Pair :
sig
val fst : ('a * 'b) t -> 'a t
val snd : ('a * 'b) t -> 'b t
end
module Triple :
sig
val fst : ('a * 'b * 'c) t -> 'a t
val snd : ('a * 'b * 'c) t -> 'b t
val trd : ('a * 'b * 'c) t -> 'c t
end
module Lift :
sig
val nullary : 'a -> 'a t
val unary : ('a -> 'b) -> 'a t -> 'b t
val binary :
('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ternary :
('a -> 'b -> 'c -> 'd) ->
'a t -> 'b t -> 'c t -> 'd t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
f:(Monoid.Unit.t -> 'a t) ->
catch:(exn -> 'a t) -> 'a t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a t t -> 'a t t
val all_ignore : 'a t t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t t -> Monoid.Unit.t t
val map : 'a t -> f:('a -> 'b t) -> 'b t t
val iter :
'a t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a t -> f:('a -> bool t) -> bool t
val for_all :
'a t -> f:('a -> bool t) -> bool t
val count :
'a t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> 'a t) -> 'a t
val find :
'a t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter : 'a t -> f:('a -> bool t) -> 'a t t
val filter_map :
'a t -> f:('a -> 'b Option.t t) -> 'b t t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map :
'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) ->
Monoid.Unit.t t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t ->
f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists :
'a T.t -> f:('a -> bool t) -> bool t
val for_all :
'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t ->
f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a T.t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t ->
f:('a -> 'b Option.t t) -> 'b T.t t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map :
'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) ->
Monoid.Unit.t t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t ->
f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists :
'a T.t -> f:('a -> bool t) -> bool t
val for_all :
'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t ->
f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a T.t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t ->
f:('a -> 'b Option.t t) -> 'b T.t t
end
end
module List :
sig
val all : 'a t list -> 'a list t
val all_ignore : 'a t list -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t list -> Monoid.Unit.t t
val map : 'a list -> f:('a -> 'b t) -> 'b list t
val iter :
'a list ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a list ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a list ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a list ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a list -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a list -> f:('a -> bool t) -> bool t
val for_all : 'a list -> f:('a -> bool t) -> bool t
val count :
'a list -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list -> f:('b -> 'a t) -> 'a t
val find :
'a list -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a list ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a list -> f:('a -> bool t) -> 'a list t
val filter_map :
'a list -> f:('a -> 'b Option.t t) -> 'b list t
end
module Seq :
sig
val all :
'a t Core_kernel.Std.Sequence.t ->
'a Core_kernel.Std.Sequence.t t
val all_ignore :
'a t Core_kernel.Std.Sequence.t ->
Monoid.Unit.t t
val sequence :
Monoid.Unit.t t Core_kernel.Std.Sequence.t ->
Monoid.Unit.t t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b t) -> 'b Core_kernel.Std.Sequence.t t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> bool t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> bool t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> 'a t) -> 'a t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> 'a Option.t t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) ->
'a Core_kernel.Std.Sequence.t t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b Option.t t) ->
'b Core_kernel.Std.Sequence.t t
end
val ( >=> ) :
('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Monad_infix :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
end
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val return : 'a -> 'a t
val map : 'a t -> f:('a -> 'b) -> 'b t
val join : 'a t t -> 'a t
val ignore_m : 'a t -> Monoid.Unit.t t
val all : 'a t list -> 'a list t
val all_ignore :
Monoid.Unit.t t list -> Monoid.Unit.t t
module Let_syntax :
sig
val return : 'a -> 'a t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Let_syntax :
sig
val return : 'a -> 'a t
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val map : 'a t -> f:('a -> 'b) -> 'b t
val both : 'a t -> 'b t -> ('a * 'b) t
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
val ( >=> ) :
('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) :
('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
type 'a error = err
val fail : err -> 'a t
val catch : 'a t -> (err -> 'a t) -> 'a t
val failf :
('a, Format.formatter, unit, unit -> 'b t)
Core_kernel.Std.format4 -> 'a
end
module T :
functor (M : Monad) ->
sig
type 'a m = 'a M.t
type 'a t =
'a Core_kernel.Std.Or_error.t
Monads.Std.Monad.Result.Error.T.m
type 'a e =
'a Core_kernel.Std.Or_error.t
Monads.Std.Monad.Result.Error.T.m
end
module Make :
functor (M : Monad) ->
sig
val lift : 'a M.t -> 'a T(M).t
val run : 'a T(M).t -> 'a T(M).e
val void : 'a T(M).t -> Monoid.Unit.t T(M).t
val sequence :
Monoid.Unit.t T(M).t list -> Monoid.Unit.t T(M).t
val forever : 'a T(M).t -> 'b T(M).t
module Fn :
sig
val id : 'a -> 'a T(M).t
val ignore : 'a T(M).t -> Monoid.Unit.t T(M).t
val nothing :
Monoid.Unit.t -> Monoid.Unit.t T(M).t
val non :
('a -> bool T(M).t) -> 'a -> bool T(M).t
val apply_n_times :
n:Monoid.Int.t ->
('a -> 'a T(M).t) -> 'a -> 'a T(M).t
val compose :
('b -> 'c T(M).t) ->
('a -> 'b T(M).t) -> 'a -> 'c T(M).t
end
module Pair :
sig
val fst : ('a * 'b) T(M).t -> 'a T(M).t
val snd : ('a * 'b) T(M).t -> 'b T(M).t
end
module Triple :
sig
val fst : ('a * 'b * 'c) T(M).t -> 'a T(M).t
val snd : ('a * 'b * 'c) T(M).t -> 'b T(M).t
val trd : ('a * 'b * 'c) T(M).t -> 'c T(M).t
end
module Lift :
sig
val nullary : 'a -> 'a T(M).t
val unary : ('a -> 'b) -> 'a T(M).t -> 'b T(M).t
val binary :
('a -> 'b -> 'c) ->
'a T(M).t -> 'b T(M).t -> 'c T(M).t
val ternary :
('a -> 'b -> 'c -> 'd) ->
'a T(M).t ->
'b T(M).t -> 'c T(M).t -> 'd T(M).t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T(M).t ->
'b T(M).t ->
'c T(M).t -> 'd T(M).t -> 'e T(M).t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T(M).t ->
'b T(M).t ->
'c T(M).t ->
'd T(M).t -> 'e T(M).t -> 'f T(M).t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t T(M).t) ->
f:(Monoid.Unit.t -> 'a T(M).t) ->
catch:(exn -> 'a T(M).t) -> 'a T(M).t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a T(M).t t -> 'a t T(M).t
val all_ignore :
'a T(M).t t -> Monoid.Unit.t T(M).t
val sequence :
Monoid.Unit.t T(M).t t ->
Monoid.Unit.t T(M).t
val map :
'a t -> f:('a -> 'b T(M).t) -> 'b t T(M).t
val iter :
'a t ->
f:('a -> Monoid.Unit.t T(M).t) ->
Monoid.Unit.t T(M).t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> 'b T(M).t) -> 'b T(M).t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> 'b T(M).t) -> 'b T(M).t
val fold_right :
'a t ->
f:('a -> 'b -> 'b T(M).t) ->
init:'b -> 'b T(M).t
val reduce :
'a t ->
f:('a -> 'a -> 'a T(M).t) ->
'a Option.t T(M).t
val exists :
'a t ->
f:('a -> bool T(M).t) -> bool T(M).t
val for_all :
'a t ->
f:('a -> bool T(M).t) -> bool T(M).t
val count :
'a t ->
f:('a -> bool T(M).t) ->
Monoid.Int.t T(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> 'a T(M).t) -> 'a T(M).t
val find :
'a t ->
f:('a -> bool T(M).t) -> 'a Option.t T(M).t
val find_map :
'a t ->
f:('a -> 'b Option.t T(M).t) ->
'b Option.t T(M).t
val filter :
'a t ->
f:('a -> bool T(M).t) -> 'a t T(M).t
val filter_map :
'a t ->
f:('a -> 'b Option.t T(M).t) -> 'b t T(M).t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : 'a T(M).t T.t -> 'a T.t T(M).t
val all_ignore :
'a T(M).t T.t -> Monoid.Unit.t T(M).t
val sequence :
Monoid.Unit.t T(M).t T.t ->
Monoid.Unit.t T(M).t
val map :
'a T.t ->
f:('a -> 'b T(M).t) -> 'b T.t T(M).t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t T(M).t) ->
Monoid.Unit.t T(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T(M).t) -> 'b T(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T(M).t) -> 'b T(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b T(M).t) ->
init:'b -> 'b T(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> 'a T(M).t) ->
'a Option.t T(M).t
val exists :
'a T.t ->
f:('a -> bool T(M).t) -> bool T(M).t
val for_all :
'a T.t ->
f:('a -> bool T(M).t) -> bool T(M).t
val count :
'a T.t ->
f:('a -> bool T(M).t) ->
Monoid.Int.t T(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> 'a T(M).t) -> 'a T(M).t
val find :
'a T.t ->
f:('a -> bool T(M).t) ->
'a Option.t T(M).t
val find_map :
'a T.t ->
f:('a -> 'b Option.t T(M).t) ->
'b Option.t T(M).t
val filter :
'a T.t ->
f:('a -> bool T(M).t) -> 'a T.t T(M).t
val filter_map :
'a T.t ->
f:('a -> 'b Option.t T(M).t) ->
'b T.t T(M).t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : 'a T(M).t T.t -> 'a T.t T(M).t
val all_ignore :
'a T(M).t T.t -> Monoid.Unit.t T(M).t
val sequence :
Monoid.Unit.t T(M).t T.t ->
Monoid.Unit.t T(M).t
val map :
'a T.t ->
f:('a -> 'b T(M).t) -> 'b T.t T(M).t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t T(M).t) ->
Monoid.Unit.t T(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T(M).t) -> 'b T(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T(M).t) -> 'b T(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b T(M).t) ->
init:'b -> 'b T(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> 'a T(M).t) ->
'a Option.t T(M).t
val exists :
'a T.t ->
f:('a -> bool T(M).t) -> bool T(M).t
val for_all :
'a T.t ->
f:('a -> bool T(M).t) -> bool T(M).t
val count :
'a T.t ->
f:('a -> bool T(M).t) ->
Monoid.Int.t T(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> 'a T(M).t) -> 'a T(M).t
val find :
'a T.t ->
f:('a -> bool T(M).t) ->
'a Option.t T(M).t
val find_map :
'a T.t ->
f:('a -> 'b Option.t T(M).t) ->
'b Option.t T(M).t
val filter :
'a T.t ->
f:('a -> bool T(M).t) -> 'a T.t T(M).t
val filter_map :
'a T.t ->
f:('a -> 'b Option.t T(M).t) ->
'b T.t T(M).t
end
end
module List :
sig
val all : 'a T(M).t list -> 'a list T(M).t
val all_ignore :
'a T(M).t list -> Monoid.Unit.t T(M).t
val sequence :
Monoid.Unit.t T(M).t list ->
Monoid.Unit.t T(M).t
val map :
'a list ->
f:('a -> 'b T(M).t) -> 'b list T(M).t
val iter :
'a list ->
f:('a -> Monoid.Unit.t T(M).t) ->
Monoid.Unit.t T(M).t
val fold :
'a list ->
init:'b ->
f:('b -> 'a -> 'b T(M).t) -> 'b T(M).t
val fold_left :
'a list ->
init:'b ->
f:('b -> 'a -> 'b T(M).t) -> 'b T(M).t
val fold_right :
'a list ->
f:('a -> 'b -> 'b T(M).t) ->
init:'b -> 'b T(M).t
val reduce :
'a list ->
f:('a -> 'a -> 'a T(M).t) -> 'a Option.t T(M).t
val exists :
'a list -> f:('a -> bool T(M).t) -> bool T(M).t
val for_all :
'a list -> f:('a -> bool T(M).t) -> bool T(M).t
val count :
'a list ->
f:('a -> bool T(M).t) -> Monoid.Int.t T(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list -> f:('b -> 'a T(M).t) -> 'a T(M).t
val find :
'a list ->
f:('a -> bool T(M).t) -> 'a Option.t T(M).t
val find_map :
'a list ->
f:('a -> 'b Option.t T(M).t) ->
'b Option.t T(M).t
val filter :
'a list ->
f:('a -> bool T(M).t) -> 'a list T(M).t
val filter_map :
'a list ->
f:('a -> 'b Option.t T(M).t) -> 'b list T(M).t
end
module Seq :
sig
val all :
'a T(M).t Core_kernel.Std.Sequence.t ->
'a Core_kernel.Std.Sequence.t T(M).t
val all_ignore :
'a T(M).t Core_kernel.Std.Sequence.t ->
Monoid.Unit.t T(M).t
val sequence :
Monoid.Unit.t T(M).t Core_kernel.Std.Sequence.t ->
Monoid.Unit.t T(M).t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b T(M).t) ->
'b Core_kernel.Std.Sequence.t T(M).t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> Monoid.Unit.t T(M).t) ->
Monoid.Unit.t T(M).t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b ->
f:('b -> 'a -> 'b T(M).t) -> 'b T(M).t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b ->
f:('b -> 'a -> 'b T(M).t) -> 'b T(M).t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> 'b T(M).t) ->
init:'b -> 'b T(M).t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> 'a T(M).t) -> 'a Option.t T(M).t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T(M).t) -> bool T(M).t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T(M).t) -> bool T(M).t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T(M).t) -> Monoid.Int.t T(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> 'a T(M).t) -> 'a T(M).t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T(M).t) -> 'a Option.t T(M).t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b Option.t T(M).t) ->
'b Option.t T(M).t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T(M).t) ->
'a Core_kernel.Std.Sequence.t T(M).t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b Option.t T(M).t) ->
'b Core_kernel.Std.Sequence.t T(M).t
end
val ( >=> ) :
('a -> 'b T(M).t) ->
('b -> 'c T(M).t) -> 'a -> 'c T(M).t
val ( !! ) : 'a -> 'a T(M).t
val ( !$ ) : ('a -> 'b) -> 'a T(M).t -> 'b T(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
'a T(M).t -> 'b T(M).t -> 'c T(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a T(M).t -> 'b T(M).t -> 'c T(M).t -> 'd T(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T(M).t ->
'b T(M).t -> 'c T(M).t -> 'd T(M).t -> 'e T(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T(M).t ->
'b T(M).t ->
'c T(M).t -> 'd T(M).t -> 'e T(M).t -> 'f T(M).t
val ( >>= ) :
'a T(M).t -> ('a -> 'b T(M).t) -> 'b T(M).t
val ( >>| ) : 'a T(M).t -> ('a -> 'b) -> 'b T(M).t
module Monad_infix :
sig
val ( >>= ) :
'a T(M).t -> ('a -> 'b T(M).t) -> 'b T(M).t
val ( >>| ) :
'a T(M).t -> ('a -> 'b) -> 'b T(M).t
end
val bind :
'a T(M).t -> f:('a -> 'b T(M).t) -> 'b T(M).t
val return : 'a -> 'a T(M).t
val map : 'a T(M).t -> f:('a -> 'b) -> 'b T(M).t
val join : 'a T(M).t T(M).t -> 'a T(M).t
val ignore_m : 'a T(M).t -> Monoid.Unit.t T(M).t
val all : 'a T(M).t list -> 'a list T(M).t
val all_ignore :
Monoid.Unit.t T(M).t list -> Monoid.Unit.t T(M).t
module Let_syntax :
sig
val return : 'a -> 'a T(M).t
val ( >>= ) :
'a T(M).t -> ('a -> 'b T(M).t) -> 'b T(M).t
val ( >>| ) :
'a T(M).t -> ('a -> 'b) -> 'b T(M).t
module Let_syntax :
sig
val return : 'a -> 'a T(M).t
val bind :
'a T(M).t ->
f:('a -> 'b T(M).t) -> 'b T(M).t
val map :
'a T(M).t -> f:('a -> 'b) -> 'b T(M).t
val both :
'a T(M).t -> 'b T(M).t -> ('a * 'b) T(M).t
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) :
'a T(M).t -> ('a -> 'b T(M).t) -> 'b T(M).t
val ( >>| ) :
'a T(M).t -> ('a -> 'b) -> 'b T(M).t
val ( >=> ) :
('a -> 'b T(M).t) ->
('b -> 'c T(M).t) -> 'a -> 'c T(M).t
val ( !! ) : 'a -> 'a T(M).t
val ( !$ ) : ('a -> 'b) -> 'a T(M).t -> 'b T(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
'a T(M).t -> 'b T(M).t -> 'c T(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a T(M).t ->
'b T(M).t -> 'c T(M).t -> 'd T(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T(M).t ->
'b T(M).t ->
'c T(M).t -> 'd T(M).t -> 'e T(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T(M).t ->
'b T(M).t ->
'c T(M).t ->
'd T(M).t -> 'e T(M).t -> 'f T(M).t
end
type 'a error = Core_kernel.Std.Error.t
val fail : Core_kernel.Std.Error.t -> 'a T(M).t
val catch :
'a T(M).t ->
(Core_kernel.Std.Error.t -> 'a T(M).t) -> 'a T(M).t
val failf :
('a, Format.formatter, Monoid.Unit.t,
Monoid.Unit.t -> 'b T(M).t)
Core_kernel.Std.format4 -> 'a
end
type 'a t = 'a Core_kernel.Std.Or_error.t
type 'a m = 'a
type 'a e = 'a t
val lift : 'a -> 'a e
val run : 'a e -> 'a e
val void : 'a e -> Monoid.Unit.t e
val sequence : Monoid.Unit.t e list -> Monoid.Unit.t e
val forever : 'a e -> 'b e
module Fn :
sig
val id : 'a -> 'a e
val ignore : 'a e -> Monoid.Unit.t e
val nothing : Monoid.Unit.t -> Monoid.Unit.t e
val non : ('a -> bool e) -> 'a -> bool e
val apply_n_times :
n:Monoid.Int.t -> ('a -> 'a e) -> 'a -> 'a e
val compose :
('b -> 'c e) -> ('a -> 'b e) -> 'a -> 'c e
end
module Pair :
sig
val fst : ('a * 'b) e -> 'a e
val snd : ('a * 'b) e -> 'b e
end
module Triple :
sig
val fst : ('a * 'b * 'c) e -> 'a e
val snd : ('a * 'b * 'c) e -> 'b e
val trd : ('a * 'b * 'c) e -> 'c e
end
module Lift :
sig
val nullary : 'a -> 'a e
val unary : ('a -> 'b) -> 'a e -> 'b e
val binary : ('a -> 'b -> 'c) -> 'a e -> 'b e -> 'c e
val ternary :
('a -> 'b -> 'c -> 'd) ->
'a e -> 'b e -> 'c e -> 'd e
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a e -> 'b e -> 'c e -> 'd e -> 'e e
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t e) ->
f:(Monoid.Unit.t -> 'a e) ->
catch:(exn -> 'a e) -> 'a e
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a e t -> 'a t e
val all_ignore : 'a e t -> Monoid.Unit.t e
val sequence : Monoid.Unit.t e t -> Monoid.Unit.t e
val map : 'a t -> f:('a -> 'b e) -> 'b t e
val iter :
'a t ->
f:('a -> Monoid.Unit.t e) -> Monoid.Unit.t e
val fold :
'a t -> init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_left :
'a t -> init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_right :
'a t -> f:('a -> 'b -> 'b e) -> init:'b -> 'b e
val reduce :
'a t -> f:('a -> 'a -> 'a e) -> 'a Option.t e
val exists : 'a t -> f:('a -> bool e) -> bool e
val for_all : 'a t -> f:('a -> bool e) -> bool e
val count :
'a t -> f:('a -> bool e) -> Monoid.Int.t e
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> 'a e) -> 'a e
val find :
'a t -> f:('a -> bool e) -> 'a Option.t e
val find_map :
'a t -> f:('a -> 'b Option.t e) -> 'b Option.t e
val filter : 'a t -> f:('a -> bool e) -> 'a t e
val filter_map :
'a t -> f:('a -> 'b Option.t e) -> 'b t e
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : 'a e T.t -> 'a T.t e
val all_ignore : 'a e T.t -> Monoid.Unit.t e
val sequence :
Monoid.Unit.t e T.t -> Monoid.Unit.t e
val map : 'a T.t -> f:('a -> 'b e) -> 'b T.t e
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t e) -> Monoid.Unit.t e
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b e) -> init:'b -> 'b e
val reduce :
'a T.t -> f:('a -> 'a -> 'a e) -> 'a Option.t e
val exists : 'a T.t -> f:('a -> bool e) -> bool e
val for_all :
'a T.t -> f:('a -> bool e) -> bool e
val count :
'a T.t -> f:('a -> bool e) -> Monoid.Int.t e
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a e) -> 'a e
val find :
'a T.t -> f:('a -> bool e) -> 'a Option.t e
val find_map :
'a T.t ->
f:('a -> 'b Option.t e) -> 'b Option.t e
val filter :
'a T.t -> f:('a -> bool e) -> 'a T.t e
val filter_map :
'a T.t -> f:('a -> 'b Option.t e) -> 'b T.t e
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : 'a e T.t -> 'a T.t e
val all_ignore : 'a e T.t -> Monoid.Unit.t e
val sequence :
Monoid.Unit.t e T.t -> Monoid.Unit.t e
val map : 'a T.t -> f:('a -> 'b e) -> 'b T.t e
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t e) -> Monoid.Unit.t e
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b e) -> init:'b -> 'b e
val reduce :
'a T.t -> f:('a -> 'a -> 'a e) -> 'a Option.t e
val exists : 'a T.t -> f:('a -> bool e) -> bool e
val for_all :
'a T.t -> f:('a -> bool e) -> bool e
val count :
'a T.t -> f:('a -> bool e) -> Monoid.Int.t e
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a e) -> 'a e
val find :
'a T.t -> f:('a -> bool e) -> 'a Option.t e
val find_map :
'a T.t ->
f:('a -> 'b Option.t e) -> 'b Option.t e
val filter :
'a T.t -> f:('a -> bool e) -> 'a T.t e
val filter_map :
'a T.t -> f:('a -> 'b Option.t e) -> 'b T.t e
end
end
module List :
sig
val all : 'a e list -> 'a list e
val all_ignore : 'a e list -> Monoid.Unit.t e
val sequence : Monoid.Unit.t e list -> Monoid.Unit.t e
val map : 'a list -> f:('a -> 'b e) -> 'b list e
val iter :
'a list ->
f:('a -> Monoid.Unit.t e) -> Monoid.Unit.t e
val fold :
'a list -> init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_left :
'a list -> init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_right :
'a list -> f:('a -> 'b -> 'b e) -> init:'b -> 'b e
val reduce :
'a list -> f:('a -> 'a -> 'a e) -> 'a Option.t e
val exists : 'a list -> f:('a -> bool e) -> bool e
val for_all : 'a list -> f:('a -> bool e) -> bool e
val count :
'a list -> f:('a -> bool e) -> Monoid.Int.t e
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list -> f:('b -> 'a e) -> 'a e
val find : 'a list -> f:('a -> bool e) -> 'a Option.t e
val find_map :
'a list -> f:('a -> 'b Option.t e) -> 'b Option.t e
val filter : 'a list -> f:('a -> bool e) -> 'a list e
val filter_map :
'a list -> f:('a -> 'b Option.t e) -> 'b list e
end
module Seq :
sig
val all :
'a e Core_kernel.Std.Sequence.t ->
'a Core_kernel.Std.Sequence.t e
val all_ignore :
'a e Core_kernel.Std.Sequence.t -> Monoid.Unit.t e
val sequence :
Monoid.Unit.t e Core_kernel.Std.Sequence.t ->
Monoid.Unit.t e
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b e) -> 'b Core_kernel.Std.Sequence.t e
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> Monoid.Unit.t e) -> Monoid.Unit.t e
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> 'b e) -> init:'b -> 'b e
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> 'a e) -> 'a Option.t e
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool e) -> bool e
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool e) -> bool e
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool e) -> Monoid.Int.t e
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> 'a e) -> 'a e
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool e) -> 'a Option.t e
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b Option.t e) -> 'b Option.t e
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool e) -> 'a Core_kernel.Std.Sequence.t e
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b Option.t e) ->
'b Core_kernel.Std.Sequence.t e
end
val ( >=> ) : ('a -> 'b e) -> ('b -> 'c e) -> 'a -> 'c e
val ( !! ) : 'a -> 'a e
val ( !$ ) : ('a -> 'b) -> 'a e -> 'b e
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a e -> 'b e -> 'c e
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a e -> 'b e -> 'c e -> 'd e -> 'e e
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
val ( >>= ) : 'a e -> ('a -> 'b e) -> 'b e
val ( >>| ) : 'a e -> ('a -> 'b) -> 'b e
module Monad_infix :
sig
val ( >>= ) : 'a e -> ('a -> 'b e) -> 'b e
val ( >>| ) : 'a e -> ('a -> 'b) -> 'b e
end
val bind : 'a e -> f:('a -> 'b e) -> 'b e
val return : 'a -> 'a e
val map : 'a e -> f:('a -> 'b) -> 'b e
val join : 'a e e -> 'a e
val ignore_m : 'a e -> Monoid.Unit.t e
val all : 'a e list -> 'a list e
val all_ignore : Monoid.Unit.t e list -> Monoid.Unit.t e
module Let_syntax :
sig
val return : 'a -> 'a e
val ( >>= ) : 'a e -> ('a -> 'b e) -> 'b e
val ( >>| ) : 'a e -> ('a -> 'b) -> 'b e
module Let_syntax :
sig
val return : 'a -> 'a e
val bind : 'a e -> f:('a -> 'b e) -> 'b e
val map : 'a e -> f:('a -> 'b) -> 'b e
val both : 'a e -> 'b e -> ('a * 'b) e
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) : 'a e -> ('a -> 'b e) -> 'b e
val ( >>| ) : 'a e -> ('a -> 'b) -> 'b e
val ( >=> ) :
('a -> 'b e) -> ('b -> 'c e) -> 'a -> 'c e
val ( !! ) : 'a -> 'a e
val ( !$ ) : ('a -> 'b) -> 'a e -> 'b e
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a e -> 'b e -> 'c e
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a e -> 'b e -> 'c e -> 'd e
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a e -> 'b e -> 'c e -> 'd e -> 'e e
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
end
type 'a error = Core_kernel.Std.Error.t
val fail : Core_kernel.Std.Error.t -> 'a e
val catch :
'a e -> (Core_kernel.Std.Error.t -> 'a e) -> 'a e
val failf :
('a, Format.formatter, Monoid.Unit.t,
Monoid.Unit.t -> 'b e)
Core_kernel.Std.format4 -> 'a
end
module Exception :
sig
type 'a t = ('a, exn) Core_kernel.Std.Result.t
type 'a m = 'a
type 'a e = ('a, exn) Core_kernel.Std.Result.t
val lift : 'a -> 'a t
val run : 'a t -> 'a e
val void : 'a t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
val forever : 'a t -> 'b t
module Fn :
sig
val id : 'a -> 'a t
val ignore : 'a t -> Monoid.Unit.t t
val nothing : Monoid.Unit.t -> Monoid.Unit.t t
val non : ('a -> bool t) -> 'a -> bool t
val apply_n_times :
n:Monoid.Int.t -> ('a -> 'a t) -> 'a -> 'a t
val compose :
('b -> 'c t) -> ('a -> 'b t) -> 'a -> 'c t
end
module Pair :
sig
val fst : ('a * 'b) t -> 'a t
val snd : ('a * 'b) t -> 'b t
end
module Triple :
sig
val fst : ('a * 'b * 'c) t -> 'a t
val snd : ('a * 'b * 'c) t -> 'b t
val trd : ('a * 'b * 'c) t -> 'c t
end
module Lift :
sig
val nullary : 'a -> 'a t
val unary : ('a -> 'b) -> 'a t -> 'b t
val binary : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ternary :
('a -> 'b -> 'c -> 'd) ->
'a t -> 'b t -> 'c t -> 'd t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
f:(Monoid.Unit.t -> 'a t) ->
catch:(exn -> 'a t) -> 'a t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a t t -> 'a t t
val all_ignore : 'a t t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
val map : 'a t -> f:('a -> 'b t) -> 'b t t
val iter :
'a t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a t -> f:('a -> bool t) -> bool t
val for_all : 'a t -> f:('a -> bool t) -> bool t
val count :
'a t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> 'a t) -> 'a t
val find :
'a t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a t -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter : 'a t -> f:('a -> bool t) -> 'a t t
val filter_map :
'a t -> f:('a -> 'b Option.t t) -> 'b t t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a T.t -> f:('a -> bool t) -> bool t
val for_all :
'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a T.t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t -> f:('a -> 'b Option.t t) -> 'b T.t t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a T.t -> f:('a -> bool t) -> bool t
val for_all :
'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a T.t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t -> f:('a -> 'b Option.t t) -> 'b T.t t
end
end
module List :
sig
val all : 'a t list -> 'a list t
val all_ignore : 'a t list -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
val map : 'a list -> f:('a -> 'b t) -> 'b list t
val iter :
'a list ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a list -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a list -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a list -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a list -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a list -> f:('a -> bool t) -> bool t
val for_all : 'a list -> f:('a -> bool t) -> bool t
val count :
'a list -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list -> f:('b -> 'a t) -> 'a t
val find : 'a list -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a list -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter : 'a list -> f:('a -> bool t) -> 'a list t
val filter_map :
'a list -> f:('a -> 'b Option.t t) -> 'b list t
end
module Seq :
sig
val all :
'a t Core_kernel.Std.Sequence.t ->
'a Core_kernel.Std.Sequence.t t
val all_ignore :
'a t Core_kernel.Std.Sequence.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t Core_kernel.Std.Sequence.t ->
Monoid.Unit.t t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b t) -> 'b Core_kernel.Std.Sequence.t t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> bool t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> bool t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> 'a t) -> 'a t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> 'a Option.t t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> 'a Core_kernel.Std.Sequence.t t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b Option.t t) ->
'b Core_kernel.Std.Sequence.t t
end
val ( >=> ) : ('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Monad_infix :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
end
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val return : 'a -> 'a t
val map : 'a t -> f:('a -> 'b) -> 'b t
val join : 'a t t -> 'a t
val ignore_m : 'a t -> Monoid.Unit.t t
val all : 'a t list -> 'a list t
val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
module Let_syntax :
sig
val return : 'a -> 'a t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Let_syntax :
sig
val return : 'a -> 'a t
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val map : 'a t -> f:('a -> 'b) -> 'b t
val both : 'a t -> 'b t -> ('a * 'b) t
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
val ( >=> ) :
('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
type 'a error = exn
val fail : exn -> 'a t
val catch : 'a t -> (exn -> 'a t) -> 'a t
module T :
functor (M : Monad) ->
sig
type 'a m = 'a M.t
type 'a t =
('a, exn) Core_kernel.Std.Result.t
Monads.Std.Monad.Result.Exception.T.m
type 'a e =
('a, exn) Core_kernel.Std.Result.t
Monads.Std.Monad.Result.Exception.T.m
end
module Make :
functor (M : Monad) ->
sig
val lift : 'a M.t -> 'a T(M).t
val run : 'a T(M).t -> 'a T(M).e
val void : 'a T(M).t -> Monoid.Unit.t T(M).t
val sequence :
Monoid.Unit.t T(M).t list -> Monoid.Unit.t T(M).t
val forever : 'a T(M).t -> 'b T(M).t
module Fn :
sig
val id : 'a -> 'a T(M).t
val ignore : 'a T(M).t -> Monoid.Unit.t T(M).t
val nothing :
Monoid.Unit.t -> Monoid.Unit.t T(M).t
val non :
('a -> bool T(M).t) -> 'a -> bool T(M).t
val apply_n_times :
n:Monoid.Int.t ->
('a -> 'a T(M).t) -> 'a -> 'a T(M).t
val compose :
('b -> 'c T(M).t) ->
('a -> 'b T(M).t) -> 'a -> 'c T(M).t
end
module Pair :
sig
val fst : ('a * 'b) T(M).t -> 'a T(M).t
val snd : ('a * 'b) T(M).t -> 'b T(M).t
end
module Triple :
sig
val fst : ('a * 'b * 'c) T(M).t -> 'a T(M).t
val snd : ('a * 'b * 'c) T(M).t -> 'b T(M).t
val trd : ('a * 'b * 'c) T(M).t -> 'c T(M).t
end
module Lift :
sig
val nullary : 'a -> 'a T(M).t
val unary : ('a -> 'b) -> 'a T(M).t -> 'b T(M).t
val binary :
('a -> 'b -> 'c) ->
'a T(M).t -> 'b T(M).t -> 'c T(M).t
val ternary :
('a -> 'b -> 'c -> 'd) ->
'a T(M).t ->
'b T(M).t -> 'c T(M).t -> 'd T(M).t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T(M).t ->
'b T(M).t ->
'c T(M).t -> 'd T(M).t -> 'e T(M).t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T(M).t ->
'b T(M).t ->
'c T(M).t ->
'd T(M).t -> 'e T(M).t -> 'f T(M).t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t T(M).t) ->
f:(Monoid.Unit.t -> 'a T(M).t) ->
catch:(exn -> 'a T(M).t) -> 'a T(M).t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a T(M).t t -> 'a t T(M).t
val all_ignore :
'a T(M).t t -> Monoid.Unit.t T(M).t
val sequence :
Monoid.Unit.t T(M).t t ->
Monoid.Unit.t T(M).t
val map :
'a t -> f:('a -> 'b T(M).t) -> 'b t T(M).t
val iter :
'a t ->
f:('a -> Monoid.Unit.t T(M).t) ->
Monoid.Unit.t T(M).t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> 'b T(M).t) -> 'b T(M).t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> 'b T(M).t) -> 'b T(M).t
val fold_right :
'a t ->
f:('a -> 'b -> 'b T(M).t) ->
init:'b -> 'b T(M).t
val reduce :
'a t ->
f:('a -> 'a -> 'a T(M).t) ->
'a Option.t T(M).t
val exists :
'a t ->
f:('a -> bool T(M).t) -> bool T(M).t
val for_all :
'a t ->
f:('a -> bool T(M).t) -> bool T(M).t
val count :
'a t ->
f:('a -> bool T(M).t) ->
Monoid.Int.t T(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> 'a T(M).t) -> 'a T(M).t
val find :
'a t ->
f:('a -> bool T(M).t) -> 'a Option.t T(M).t
val find_map :
'a t ->
f:('a -> 'b Option.t T(M).t) ->
'b Option.t T(M).t
val filter :
'a t ->
f:('a -> bool T(M).t) -> 'a t T(M).t
val filter_map :
'a t ->
f:('a -> 'b Option.t T(M).t) -> 'b t T(M).t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : 'a T(M).t T.t -> 'a T.t T(M).t
val all_ignore :
'a T(M).t T.t -> Monoid.Unit.t T(M).t
val sequence :
Monoid.Unit.t T(M).t T.t ->
Monoid.Unit.t T(M).t
val map :
'a T.t ->
f:('a -> 'b T(M).t) -> 'b T.t T(M).t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t T(M).t) ->
Monoid.Unit.t T(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T(M).t) -> 'b T(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T(M).t) -> 'b T(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b T(M).t) ->
init:'b -> 'b T(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> 'a T(M).t) ->
'a Option.t T(M).t
val exists :
'a T.t ->
f:('a -> bool T(M).t) -> bool T(M).t
val for_all :
'a T.t ->
f:('a -> bool T(M).t) -> bool T(M).t
val count :
'a T.t ->
f:('a -> bool T(M).t) ->
Monoid.Int.t T(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> 'a T(M).t) -> 'a T(M).t
val find :
'a T.t ->
f:('a -> bool T(M).t) ->
'a Option.t T(M).t
val find_map :
'a T.t ->
f:('a -> 'b Option.t T(M).t) ->
'b Option.t T(M).t
val filter :
'a T.t ->
f:('a -> bool T(M).t) -> 'a T.t T(M).t
val filter_map :
'a T.t ->
f:('a -> 'b Option.t T(M).t) ->
'b T.t T(M).t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : 'a T(M).t T.t -> 'a T.t T(M).t
val all_ignore :
'a T(M).t T.t -> Monoid.Unit.t T(M).t
val sequence :
Monoid.Unit.t T(M).t T.t ->
Monoid.Unit.t T(M).t
val map :
'a T.t ->
f:('a -> 'b T(M).t) -> 'b T.t T(M).t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t T(M).t) ->
Monoid.Unit.t T(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T(M).t) -> 'b T(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T(M).t) -> 'b T(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b T(M).t) ->
init:'b -> 'b T(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> 'a T(M).t) ->
'a Option.t T(M).t
val exists :
'a T.t ->
f:('a -> bool T(M).t) -> bool T(M).t
val for_all :
'a T.t ->
f:('a -> bool T(M).t) -> bool T(M).t
val count :
'a T.t ->
f:('a -> bool T(M).t) ->
Monoid.Int.t T(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> 'a T(M).t) -> 'a T(M).t
val find :
'a T.t ->
f:('a -> bool T(M).t) ->
'a Option.t T(M).t
val find_map :
'a T.t ->
f:('a -> 'b Option.t T(M).t) ->
'b Option.t T(M).t
val filter :
'a T.t ->
f:('a -> bool T(M).t) -> 'a T.t T(M).t
val filter_map :
'a T.t ->
f:('a -> 'b Option.t T(M).t) ->
'b T.t T(M).t
end
end
module List :
sig
val all : 'a T(M).t list -> 'a list T(M).t
val all_ignore :
'a T(M).t list -> Monoid.Unit.t T(M).t
val sequence :
Monoid.Unit.t T(M).t list ->
Monoid.Unit.t T(M).t
val map :
'a list ->
f:('a -> 'b T(M).t) -> 'b list T(M).t
val iter :
'a list ->
f:('a -> Monoid.Unit.t T(M).t) ->
Monoid.Unit.t T(M).t
val fold :
'a list ->
init:'b ->
f:('b -> 'a -> 'b T(M).t) -> 'b T(M).t
val fold_left :
'a list ->
init:'b ->
f:('b -> 'a -> 'b T(M).t) -> 'b T(M).t
val fold_right :
'a list ->
f:('a -> 'b -> 'b T(M).t) ->
init:'b -> 'b T(M).t
val reduce :
'a list ->
f:('a -> 'a -> 'a T(M).t) -> 'a Option.t T(M).t
val exists :
'a list -> f:('a -> bool T(M).t) -> bool T(M).t
val for_all :
'a list -> f:('a -> bool T(M).t) -> bool T(M).t
val count :
'a list ->
f:('a -> bool T(M).t) -> Monoid.Int.t T(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list -> f:('b -> 'a T(M).t) -> 'a T(M).t
val find :
'a list ->
f:('a -> bool T(M).t) -> 'a Option.t T(M).t
val find_map :
'a list ->
f:('a -> 'b Option.t T(M).t) ->
'b Option.t T(M).t
val filter :
'a list ->
f:('a -> bool T(M).t) -> 'a list T(M).t
val filter_map :
'a list ->
f:('a -> 'b Option.t T(M).t) -> 'b list T(M).t
end
module Seq :
sig
val all :
'a T(M).t Core_kernel.Std.Sequence.t ->
'a Core_kernel.Std.Sequence.t T(M).t
val all_ignore :
'a T(M).t Core_kernel.Std.Sequence.t ->
Monoid.Unit.t T(M).t
val sequence :
Monoid.Unit.t T(M).t Core_kernel.Std.Sequence.t ->
Monoid.Unit.t T(M).t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b T(M).t) ->
'b Core_kernel.Std.Sequence.t T(M).t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> Monoid.Unit.t T(M).t) ->
Monoid.Unit.t T(M).t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b ->
f:('b -> 'a -> 'b T(M).t) -> 'b T(M).t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b ->
f:('b -> 'a -> 'b T(M).t) -> 'b T(M).t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> 'b T(M).t) ->
init:'b -> 'b T(M).t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> 'a T(M).t) -> 'a Option.t T(M).t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T(M).t) -> bool T(M).t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T(M).t) -> bool T(M).t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T(M).t) -> Monoid.Int.t T(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> 'a T(M).t) -> 'a T(M).t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T(M).t) -> 'a Option.t T(M).t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b Option.t T(M).t) ->
'b Option.t T(M).t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T(M).t) ->
'a Core_kernel.Std.Sequence.t T(M).t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b Option.t T(M).t) ->
'b Core_kernel.Std.Sequence.t T(M).t
end
val ( >=> ) :
('a -> 'b T(M).t) ->
('b -> 'c T(M).t) -> 'a -> 'c T(M).t
val ( !! ) : 'a -> 'a T(M).t
val ( !$ ) : ('a -> 'b) -> 'a T(M).t -> 'b T(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
'a T(M).t -> 'b T(M).t -> 'c T(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a T(M).t -> 'b T(M).t -> 'c T(M).t -> 'd T(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T(M).t ->
'b T(M).t -> 'c T(M).t -> 'd T(M).t -> 'e T(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T(M).t ->
'b T(M).t ->
'c T(M).t -> 'd T(M).t -> 'e T(M).t -> 'f T(M).t
val ( >>= ) :
'a T(M).t -> ('a -> 'b T(M).t) -> 'b T(M).t
val ( >>| ) : 'a T(M).t -> ('a -> 'b) -> 'b T(M).t
module Monad_infix :
sig
val ( >>= ) :
'a T(M).t -> ('a -> 'b T(M).t) -> 'b T(M).t
val ( >>| ) :
'a T(M).t -> ('a -> 'b) -> 'b T(M).t
end
val bind :
'a T(M).t -> f:('a -> 'b T(M).t) -> 'b T(M).t
val return : 'a -> 'a T(M).t
val map : 'a T(M).t -> f:('a -> 'b) -> 'b T(M).t
val join : 'a T(M).t T(M).t -> 'a T(M).t
val ignore_m : 'a T(M).t -> Monoid.Unit.t T(M).t
val all : 'a T(M).t list -> 'a list T(M).t
val all_ignore :
Monoid.Unit.t T(M).t list -> Monoid.Unit.t T(M).t
module Let_syntax :
sig
val return : 'a -> 'a T(M).t
val ( >>= ) :
'a T(M).t -> ('a -> 'b T(M).t) -> 'b T(M).t
val ( >>| ) :
'a T(M).t -> ('a -> 'b) -> 'b T(M).t
module Let_syntax :
sig
val return : 'a -> 'a T(M).t
val bind :
'a T(M).t ->
f:('a -> 'b T(M).t) -> 'b T(M).t
val map :
'a T(M).t -> f:('a -> 'b) -> 'b T(M).t
val both :
'a T(M).t -> 'b T(M).t -> ('a * 'b) T(M).t
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) :
'a T(M).t -> ('a -> 'b T(M).t) -> 'b T(M).t
val ( >>| ) :
'a T(M).t -> ('a -> 'b) -> 'b T(M).t
val ( >=> ) :
('a -> 'b T(M).t) ->
('b -> 'c T(M).t) -> 'a -> 'c T(M).t
val ( !! ) : 'a -> 'a T(M).t
val ( !$ ) : ('a -> 'b) -> 'a T(M).t -> 'b T(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
'a T(M).t -> 'b T(M).t -> 'c T(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a T(M).t ->
'b T(M).t -> 'c T(M).t -> 'd T(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T(M).t ->
'b T(M).t ->
'c T(M).t -> 'd T(M).t -> 'e T(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T(M).t ->
'b T(M).t ->
'c T(M).t ->
'd T(M).t -> 'e T(M).t -> 'f T(M).t
end
type 'a error = exn
val fail : exn -> 'a T(M).t
val catch :
'a T(M).t -> (exn -> 'a T(M).t) -> 'a T(M).t
end
end
end
module List :
sig
module type S =
sig
type 'a t
type 'a m
type 'a e
val lift : 'a m -> 'a t
val run : 'a t -> 'a e
val void : 'a t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
val forever : 'a t -> 'b t
module Fn :
sig
val id : 'a -> 'a t
val ignore : 'a t -> Monoid.Unit.t t
val nothing : Monoid.Unit.t -> Monoid.Unit.t t
val non : ('a -> bool t) -> 'a -> bool t
val apply_n_times :
n:Monoid.Int.t -> ('a -> 'a t) -> 'a -> 'a t
val compose :
('b -> 'c t) -> ('a -> 'b t) -> 'a -> 'c t
end
module Pair :
sig
val fst : ('a * 'b) t -> 'a t
val snd : ('a * 'b) t -> 'b t
end
module Triple :
sig
val fst : ('a * 'b * 'c) t -> 'a t
val snd : ('a * 'b * 'c) t -> 'b t
val trd : ('a * 'b * 'c) t -> 'c t
end
module Lift :
sig
val nullary : 'a -> 'a t
val unary : ('a -> 'b) -> 'a t -> 'b t
val binary : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ternary :
('a -> 'b -> 'c -> 'd) ->
'a t -> 'b t -> 'c t -> 'd t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
f:(Monoid.Unit.t -> 'a t) ->
catch:(exn -> 'a t) -> 'a t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a t t -> 'a t t
val all_ignore : 'a t t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
val map : 'a t -> f:('a -> 'b t) -> 'b t t
val iter :
'a t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a t -> f:('a -> bool t) -> bool t
val for_all : 'a t -> f:('a -> bool t) -> bool t
val count :
'a t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> 'a t) -> 'a t
val find :
'a t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a t -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter : 'a t -> f:('a -> bool t) -> 'a t t
val filter_map :
'a t -> f:('a -> 'b Option.t t) -> 'b t t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a T.t -> f:('a -> bool t) -> bool t
val for_all :
'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a T.t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t -> f:('a -> 'b Option.t t) -> 'b T.t t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a T.t -> f:('a -> bool t) -> bool t
val for_all :
'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a T.t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t -> f:('a -> 'b Option.t t) -> 'b T.t t
end
end
module List :
sig
val all : 'a t list -> 'a list t
val all_ignore : 'a t list -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
val map : 'a list -> f:('a -> 'b t) -> 'b list t
val iter :
'a list ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a list -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a list -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a list -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a list -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a list -> f:('a -> bool t) -> bool t
val for_all : 'a list -> f:('a -> bool t) -> bool t
val count :
'a list -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list -> f:('b -> 'a t) -> 'a t
val find : 'a list -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a list -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter : 'a list -> f:('a -> bool t) -> 'a list t
val filter_map :
'a list -> f:('a -> 'b Option.t t) -> 'b list t
end
module Seq :
sig
val all :
'a t Core_kernel.Std.Sequence.t ->
'a Core_kernel.Std.Sequence.t t
val all_ignore :
'a t Core_kernel.Std.Sequence.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t Core_kernel.Std.Sequence.t ->
Monoid.Unit.t t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b t) -> 'b Core_kernel.Std.Sequence.t t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> bool t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> bool t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> 'a t) -> 'a t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> 'a Option.t t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> 'a Core_kernel.Std.Sequence.t t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b Option.t t) ->
'b Core_kernel.Std.Sequence.t t
end
val ( >=> ) : ('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Monad_infix :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
end
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val return : 'a -> 'a t
val map : 'a t -> f:('a -> 'b) -> 'b t
val join : 'a t t -> 'a t
val ignore_m : 'a t -> Monoid.Unit.t t
val all : 'a t list -> 'a list t
val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
module Let_syntax :
sig
val return : 'a -> 'a t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Let_syntax :
sig
val return : 'a -> 'a t
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val map : 'a t -> f:('a -> 'b) -> 'b t
val both : 'a t -> 'b t -> ('a * 'b) t
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
val ( >=> ) :
('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
val pure : 'a -> 'a t
val accept : 'a -> 'a t
val reject : Monoid.Unit.t -> 'a t
val guard : bool -> Monoid.Unit.t t
val on : bool -> Monoid.Unit.t t -> Monoid.Unit.t t
val unless : bool -> Monoid.Unit.t t -> Monoid.Unit.t t
val zero : Monoid.Unit.t -> 'a t
val plus : 'a t -> 'a t -> 'a t
end
module type S2 =
sig
type ('a, 'e) t
type ('a, 'e) m
type ('a, 'e) e
val lift : ('a, 'e) m -> ('a, 'e) t
val run : ('a, 'e) t -> ('a, 'e) e
val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
val forever : ('a, 'e) t -> ('b, 'e) t
module Fn :
sig
val id : 'a -> ('a, 'e) t
val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
val non : ('a -> (bool, 'e) t) -> 'a -> (bool, 'e) t
val apply_n_times :
n:Monoid.Int.t ->
('a -> ('a, 'e) t) -> 'a -> ('a, 'e) t
val compose :
('b -> ('c, 'e) t) ->
('a -> ('b, 'e) t) -> 'a -> ('c, 'e) t
end
module Pair :
sig
val fst : ('a * 'b, 'e) t -> ('a, 'e) t
val snd : ('a * 'b, 'e) t -> ('b, 'e) t
end
module Triple :
sig
val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
end
module Lift :
sig
val nullary : 'a -> ('a, 'e) t
val unary : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val binary :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ternary :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
f:(Monoid.Unit.t -> ('a, 's) t) ->
catch:(exn -> ('a, 's) t) -> ('a, 's) t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : ('a, 'e) t t -> ('a t, 'e) t
val all_ignore :
('a, 'e) t t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
val map :
'a t -> f:('a -> ('b, 'e) t) -> ('b t, 'e) t
val iter :
'a t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a t -> f:('a -> (bool, 'e) t) -> ('a t, 'e) t
val filter_map :
'a t ->
f:('a -> ('b Option.t, 'e) t) -> ('b t, 'e) t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : ('a, 'e) t T.t -> ('a T.t, 'e) t
val all_ignore :
('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t T.t ->
(Monoid.Unit.t, 'e) t
val map :
'a T.t ->
f:('a -> ('b, 'e) t) -> ('b T.t, 'e) t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) t) ->
('a Option.t, 'e) t
val exists :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a T.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a T.t, 'e) t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b T.t, 'e) t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : ('a, 'e) t T.t -> ('a T.t, 'e) t
val all_ignore :
('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t T.t ->
(Monoid.Unit.t, 'e) t
val map :
'a T.t ->
f:('a -> ('b, 'e) t) -> ('b T.t, 'e) t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) t) ->
('a Option.t, 'e) t
val exists :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a T.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a T.t, 'e) t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b T.t, 'e) t
end
end
module List :
sig
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore :
('a, 'e) t list -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
val map :
'a list -> f:('a -> ('b, 'e) t) -> ('b list, 'e) t
val iter :
'a list ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a list ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a list ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a list ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a list ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a list -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a list -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a list ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a list ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a list ->
f:('a -> ('b Option.t, 'e) t) -> ('b Option.t, 'e) t
val filter :
'a list -> f:('a -> (bool, 'e) t) -> ('a list, 'e) t
val filter_map :
'a list ->
f:('a -> ('b Option.t, 'e) t) -> ('b list, 'e) t
end
module Seq :
sig
val all :
('a, 'e) t Core_kernel.Std.Sequence.t ->
('a Core_kernel.Std.Sequence.t, 'e) t
val all_ignore :
('a, 'e) t Core_kernel.Std.Sequence.t ->
(Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t Core_kernel.Std.Sequence.t ->
(Monoid.Unit.t, 'e) t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b, 'e) t) ->
('b Core_kernel.Std.Sequence.t, 'e) t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b Option.t, 'e) t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) ->
('a Core_kernel.Std.Sequence.t, 'e) t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Core_kernel.Std.Sequence.t, 'e) t
end
val ( >=> ) :
('a -> ('b, 'e) t) ->
('b -> ('c, 'e) t) -> 'a -> ('c, 'e) t
val ( !! ) : 'a -> ('a, 'e) t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val bind :
('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val both :
('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
end
val bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val return : 'a -> ('a, 'b) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore :
(Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
module Syntax :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
val ( >=> ) :
('a -> ('b, 'e) t) ->
('b -> ('c, 'e) t) -> 'a -> ('c, 'e) t
val ( !! ) : 'a -> ('a, 'e) t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
end
val pure : 'a -> ('a, 'e) t
val accept : 'a -> ('a, 'e) t
val reject : Monoid.Unit.t -> ('a, 'e) t
val guard : bool -> (Monoid.Unit.t, 'e) t
val on :
bool -> (Monoid.Unit.t, 'e) t -> (Monoid.Unit.t, 'e) t
val unless :
bool -> (Monoid.Unit.t, 'e) t -> (Monoid.Unit.t, 'e) t
val zero : Monoid.Unit.t -> ('a, 'e) t
val plus : ('a, 'e) t -> ('a, 'e) t -> ('a, 'e) t
end
type 'a t = 'a list
type 'a m = 'a
type 'a e = 'a t
val lift : 'a -> 'a e
val run : 'a e -> 'a e
val void : 'a e -> Monoid.Unit.t e
val sequence : Monoid.Unit.t e e -> Monoid.Unit.t e
val forever : 'a e -> 'b e
module Fn :
sig
val id : 'a -> 'a e
val ignore : 'a e -> Monoid.Unit.t e
val nothing : Monoid.Unit.t -> Monoid.Unit.t e
val non : ('a -> bool e) -> 'a -> bool e
val apply_n_times :
n:Monoid.Int.t -> ('a -> 'a e) -> 'a -> 'a e
val compose : ('b -> 'c e) -> ('a -> 'b e) -> 'a -> 'c e
end
module Pair :
sig
val fst : ('a * 'b) e -> 'a e
val snd : ('a * 'b) e -> 'b e
end
module Triple :
sig
val fst : ('a * 'b * 'c) e -> 'a e
val snd : ('a * 'b * 'c) e -> 'b e
val trd : ('a * 'b * 'c) e -> 'c e
end
module Lift :
sig
val nullary : 'a -> 'a e
val unary : ('a -> 'b) -> 'a e -> 'b e
val binary : ('a -> 'b -> 'c) -> 'a e -> 'b e -> 'c e
val ternary :
('a -> 'b -> 'c -> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a e -> 'b e -> 'c e -> 'd e -> 'e e
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t e) ->
f:(Monoid.Unit.t -> 'a e) -> catch:(exn -> 'a e) -> 'a e
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a e t -> 'a t e
val all_ignore : 'a e t -> Monoid.Unit.t e
val sequence : Monoid.Unit.t e t -> Monoid.Unit.t e
val map : 'a t -> f:('a -> 'b e) -> 'b t e
val iter :
'a t -> f:('a -> Monoid.Unit.t e) -> Monoid.Unit.t e
val fold :
'a t -> init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_left :
'a t -> init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_right :
'a t -> f:('a -> 'b -> 'b e) -> init:'b -> 'b e
val reduce :
'a t -> f:('a -> 'a -> 'a e) -> 'a Option.t e
val exists : 'a t -> f:('a -> bool e) -> bool e
val for_all : 'a t -> f:('a -> bool e) -> bool e
val count : 'a t -> f:('a -> bool e) -> Monoid.Int.t e
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> 'a e) -> 'a e
val find : 'a t -> f:('a -> bool e) -> 'a Option.t e
val find_map :
'a t -> f:('a -> 'b Option.t e) -> 'b Option.t e
val filter : 'a t -> f:('a -> bool e) -> 'a t e
val filter_map :
'a t -> f:('a -> 'b Option.t e) -> 'b t e
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : 'a e T.t -> 'a T.t e
val all_ignore : 'a e T.t -> Monoid.Unit.t e
val sequence : Monoid.Unit.t e T.t -> Monoid.Unit.t e
val map : 'a T.t -> f:('a -> 'b e) -> 'b T.t e
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t e) -> Monoid.Unit.t e
val fold :
'a T.t -> init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_left :
'a T.t -> init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_right :
'a T.t -> f:('a -> 'b -> 'b e) -> init:'b -> 'b e
val reduce :
'a T.t -> f:('a -> 'a -> 'a e) -> 'a Option.t e
val exists : 'a T.t -> f:('a -> bool e) -> bool e
val for_all : 'a T.t -> f:('a -> bool e) -> bool e
val count :
'a T.t -> f:('a -> bool e) -> Monoid.Int.t e
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a e) -> 'a e
val find :
'a T.t -> f:('a -> bool e) -> 'a Option.t e
val find_map :
'a T.t -> f:('a -> 'b Option.t e) -> 'b Option.t e
val filter : 'a T.t -> f:('a -> bool e) -> 'a T.t e
val filter_map :
'a T.t -> f:('a -> 'b Option.t e) -> 'b T.t e
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : 'a e T.t -> 'a T.t e
val all_ignore : 'a e T.t -> Monoid.Unit.t e
val sequence : Monoid.Unit.t e T.t -> Monoid.Unit.t e
val map : 'a T.t -> f:('a -> 'b e) -> 'b T.t e
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t e) -> Monoid.Unit.t e
val fold :
'a T.t -> init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_left :
'a T.t -> init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_right :
'a T.t -> f:('a -> 'b -> 'b e) -> init:'b -> 'b e
val reduce :
'a T.t -> f:('a -> 'a -> 'a e) -> 'a Option.t e
val exists : 'a T.t -> f:('a -> bool e) -> bool e
val for_all : 'a T.t -> f:('a -> bool e) -> bool e
val count :
'a T.t -> f:('a -> bool e) -> Monoid.Int.t e
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a e) -> 'a e
val find :
'a T.t -> f:('a -> bool e) -> 'a Option.t e
val find_map :
'a T.t -> f:('a -> 'b Option.t e) -> 'b Option.t e
val filter : 'a T.t -> f:('a -> bool e) -> 'a T.t e
val filter_map :
'a T.t -> f:('a -> 'b Option.t e) -> 'b T.t e
end
end
module List :
sig
val all : 'a e e -> 'a e e
val all_ignore : 'a e e -> Monoid.Unit.t e
val sequence : Monoid.Unit.t e e -> Monoid.Unit.t e
val map : 'a e -> f:('a -> 'b e) -> 'b e e
val iter :
'a e -> f:('a -> Monoid.Unit.t e) -> Monoid.Unit.t e
val fold : 'a e -> init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_left :
'a e -> init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_right :
'a e -> f:('a -> 'b -> 'b e) -> init:'b -> 'b e
val reduce : 'a e -> f:('a -> 'a -> 'a e) -> 'a Option.t e
val exists : 'a e -> f:('a -> bool e) -> bool e
val for_all : 'a e -> f:('a -> bool e) -> bool e
val count : 'a e -> f:('a -> bool e) -> Monoid.Int.t e
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b e -> f:('b -> 'a e) -> 'a e
val find : 'a e -> f:('a -> bool e) -> 'a Option.t e
val find_map :
'a e -> f:('a -> 'b Option.t e) -> 'b Option.t e
val filter : 'a e -> f:('a -> bool e) -> 'a e e
val filter_map : 'a e -> f:('a -> 'b Option.t e) -> 'b e e
end
module Seq :
sig
val all :
'a e Core_kernel.Std.Sequence.t ->
'a Core_kernel.Std.Sequence.t e
val all_ignore :
'a e Core_kernel.Std.Sequence.t -> Monoid.Unit.t e
val sequence :
Monoid.Unit.t e Core_kernel.Std.Sequence.t ->
Monoid.Unit.t e
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b e) -> 'b Core_kernel.Std.Sequence.t e
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> Monoid.Unit.t e) -> Monoid.Unit.t e
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> 'b e) -> init:'b -> 'b e
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> 'a e) -> 'a Option.t e
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool e) -> bool e
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool e) -> bool e
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool e) -> Monoid.Int.t e
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t -> f:('b -> 'a e) -> 'a e
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool e) -> 'a Option.t e
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b Option.t e) -> 'b Option.t e
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool e) -> 'a Core_kernel.Std.Sequence.t e
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b Option.t e) ->
'b Core_kernel.Std.Sequence.t e
end
val ( >=> ) : ('a -> 'b e) -> ('b -> 'c e) -> 'a -> 'c e
val ( !! ) : 'a -> 'a e
val ( !$ ) : ('a -> 'b) -> 'a e -> 'b e
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a e -> 'b e -> 'c e
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a e -> 'b e -> 'c e -> 'd e -> 'e e
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
val ( >>= ) : 'a e -> ('a -> 'b e) -> 'b e
val ( >>| ) : 'a e -> ('a -> 'b) -> 'b e
module Monad_infix :
sig
val ( >>= ) : 'a e -> ('a -> 'b e) -> 'b e
val ( >>| ) : 'a e -> ('a -> 'b) -> 'b e
end
val bind : 'a e -> f:('a -> 'b e) -> 'b e
val return : 'a -> 'a e
val map : 'a e -> f:('a -> 'b) -> 'b e
val join : 'a e e -> 'a e
val ignore_m : 'a e -> Monoid.Unit.t e
val all : 'a e e -> 'a e e
val all_ignore : Monoid.Unit.t e e -> Monoid.Unit.t e
module Let_syntax :
sig
val return : 'a -> 'a e
val ( >>= ) : 'a e -> ('a -> 'b e) -> 'b e
val ( >>| ) : 'a e -> ('a -> 'b) -> 'b e
module Let_syntax :
sig
val return : 'a -> 'a e
val bind : 'a e -> f:('a -> 'b e) -> 'b e
val map : 'a e -> f:('a -> 'b) -> 'b e
val both : 'a e -> 'b e -> ('a * 'b) e
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) : 'a e -> ('a -> 'b e) -> 'b e
val ( >>| ) : 'a e -> ('a -> 'b) -> 'b e
val ( >=> ) : ('a -> 'b e) -> ('b -> 'c e) -> 'a -> 'c e
val ( !! ) : 'a -> 'a e
val ( !$ ) : ('a -> 'b) -> 'a e -> 'b e
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a e -> 'b e -> 'c e
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a e -> 'b e -> 'c e -> 'd e -> 'e e
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
end
val pure : 'a -> 'a e
val accept : 'a -> 'a e
val reject : Monoid.Unit.t -> 'a e
val guard : bool -> Monoid.Unit.t e
val on : bool -> Monoid.Unit.t e -> Monoid.Unit.t e
val unless : bool -> Monoid.Unit.t e -> Monoid.Unit.t e
val zero : Monoid.Unit.t -> 'a e
val plus : 'a e -> 'a e -> 'a e
module T1 :
functor (M : Core_kernel.Std.T1) ->
sig
type 'a t = 'a list M.t
type 'a m = 'a M.t
type 'a e = 'a Monads.Std.Monad.List.T1.t
end
module Make :
functor (M : Monad) ->
sig
val lift : 'a M.t -> 'a T1(M).t
val run : 'a T1(M).t -> 'a Monads.Std.Monad.List.T1.t
val void : 'a T1(M).t -> Monoid.Unit.t T1(M).t
val sequence :
Monoid.Unit.t T1(M).t e -> Monoid.Unit.t T1(M).t
val forever : 'a T1(M).t -> 'b T1(M).t
module Fn :
sig
val id : 'a -> 'a T1(M).t
val ignore : 'a T1(M).t -> Monoid.Unit.t T1(M).t
val nothing : Monoid.Unit.t -> Monoid.Unit.t T1(M).t
val non : ('a -> bool T1(M).t) -> 'a -> bool T1(M).t
val apply_n_times :
n:Monoid.Int.t ->
('a -> 'a T1(M).t) -> 'a -> 'a T1(M).t
val compose :
('b -> 'c T1(M).t) ->
('a -> 'b T1(M).t) -> 'a -> 'c T1(M).t
end
module Pair :
sig
val fst : ('a * 'b) T1(M).t -> 'a T1(M).t
val snd : ('a * 'b) T1(M).t -> 'b T1(M).t
end
module Triple :
sig
val fst : ('a * 'b * 'c) T1(M).t -> 'a T1(M).t
val snd : ('a * 'b * 'c) T1(M).t -> 'b T1(M).t
val trd : ('a * 'b * 'c) T1(M).t -> 'c T1(M).t
end
module Lift :
sig
val nullary : 'a -> 'a T1(M).t
val unary : ('a -> 'b) -> 'a T1(M).t -> 'b T1(M).t
val binary :
('a -> 'b -> 'c) ->
'a T1(M).t -> 'b T1(M).t -> 'c T1(M).t
val ternary :
('a -> 'b -> 'c -> 'd) ->
'a T1(M).t ->
'b T1(M).t -> 'c T1(M).t -> 'd T1(M).t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(M).t ->
'b T1(M).t ->
'c T1(M).t -> 'd T1(M).t -> 'e T1(M).t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(M).t ->
'b T1(M).t ->
'c T1(M).t ->
'd T1(M).t -> 'e T1(M).t -> 'f T1(M).t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t T1(M).t) ->
f:(Monoid.Unit.t -> 'a T1(M).t) ->
catch:(exn -> 'a T1(M).t) -> 'a T1(M).t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a T1(M).t t -> 'a t T1(M).t
val all_ignore :
'a T1(M).t t -> Monoid.Unit.t T1(M).t
val sequence :
Monoid.Unit.t T1(M).t t ->
Monoid.Unit.t T1(M).t
val map :
'a t -> f:('a -> 'b T1(M).t) -> 'b t T1(M).t
val iter :
'a t ->
f:('a -> Monoid.Unit.t T1(M).t) ->
Monoid.Unit.t T1(M).t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_right :
'a t ->
f:('a -> 'b -> 'b T1(M).t) ->
init:'b -> 'b T1(M).t
val reduce :
'a t ->
f:('a -> 'a -> 'a T1(M).t) ->
'a Option.t T1(M).t
val exists :
'a t -> f:('a -> bool T1(M).t) -> bool T1(M).t
val for_all :
'a t -> f:('a -> bool T1(M).t) -> bool T1(M).t
val count :
'a t ->
f:('a -> bool T1(M).t) -> Monoid.Int.t T1(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> 'a T1(M).t) -> 'a T1(M).t
val find :
'a t ->
f:('a -> bool T1(M).t) -> 'a Option.t T1(M).t
val find_map :
'a t ->
f:('a -> 'b Option.t T1(M).t) ->
'b Option.t T1(M).t
val filter :
'a t -> f:('a -> bool T1(M).t) -> 'a t T1(M).t
val filter_map :
'a t ->
f:('a -> 'b Option.t T1(M).t) -> 'b t T1(M).t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : 'a T1(M).t T.t -> 'a T.t T1(M).t
val all_ignore :
'a T1(M).t T.t -> Monoid.Unit.t T1(M).t
val sequence :
Monoid.Unit.t T1(M).t T.t ->
Monoid.Unit.t T1(M).t
val map :
'a T.t ->
f:('a -> 'b T1(M).t) -> 'b T.t T1(M).t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t T1(M).t) ->
Monoid.Unit.t T1(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b T1(M).t) ->
init:'b -> 'b T1(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> 'a T1(M).t) ->
'a Option.t T1(M).t
val exists :
'a T.t ->
f:('a -> bool T1(M).t) -> bool T1(M).t
val for_all :
'a T.t ->
f:('a -> bool T1(M).t) -> bool T1(M).t
val count :
'a T.t ->
f:('a -> bool T1(M).t) ->
Monoid.Int.t T1(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a T1(M).t) -> 'a T1(M).t
val find :
'a T.t ->
f:('a -> bool T1(M).t) -> 'a Option.t T1(M).t
val find_map :
'a T.t ->
f:('a -> 'b Option.t T1(M).t) ->
'b Option.t T1(M).t
val filter :
'a T.t ->
f:('a -> bool T1(M).t) -> 'a T.t T1(M).t
val filter_map :
'a T.t ->
f:('a -> 'b Option.t T1(M).t) ->
'b T.t T1(M).t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : 'a T1(M).t T.t -> 'a T.t T1(M).t
val all_ignore :
'a T1(M).t T.t -> Monoid.Unit.t T1(M).t
val sequence :
Monoid.Unit.t T1(M).t T.t ->
Monoid.Unit.t T1(M).t
val map :
'a T.t ->
f:('a -> 'b T1(M).t) -> 'b T.t T1(M).t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t T1(M).t) ->
Monoid.Unit.t T1(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b T1(M).t) ->
init:'b -> 'b T1(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> 'a T1(M).t) ->
'a Option.t T1(M).t
val exists :
'a T.t ->
f:('a -> bool T1(M).t) -> bool T1(M).t
val for_all :
'a T.t ->
f:('a -> bool T1(M).t) -> bool T1(M).t
val count :
'a T.t ->
f:('a -> bool T1(M).t) ->
Monoid.Int.t T1(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a T1(M).t) -> 'a T1(M).t
val find :
'a T.t ->
f:('a -> bool T1(M).t) -> 'a Option.t T1(M).t
val find_map :
'a T.t ->
f:('a -> 'b Option.t T1(M).t) ->
'b Option.t T1(M).t
val filter :
'a T.t ->
f:('a -> bool T1(M).t) -> 'a T.t T1(M).t
val filter_map :
'a T.t ->
f:('a -> 'b Option.t T1(M).t) ->
'b T.t T1(M).t
end
end
module List :
sig
val all : 'a T1(M).t e -> 'a e T1(M).t
val all_ignore :
'a T1(M).t e -> Monoid.Unit.t T1(M).t
val sequence :
Monoid.Unit.t T1(M).t e -> Monoid.Unit.t T1(M).t
val map :
'a e -> f:('a -> 'b T1(M).t) -> 'b e T1(M).t
val iter :
'a e ->
f:('a -> Monoid.Unit.t T1(M).t) ->
Monoid.Unit.t T1(M).t
val fold :
'a e ->
init:'b -> f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_left :
'a e ->
init:'b -> f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_right :
'a e ->
f:('a -> 'b -> 'b T1(M).t) -> init:'b -> 'b T1(M).t
val reduce :
'a e ->
f:('a -> 'a -> 'a T1(M).t) -> 'a Option.t T1(M).t
val exists :
'a e -> f:('a -> bool T1(M).t) -> bool T1(M).t
val for_all :
'a e -> f:('a -> bool T1(M).t) -> bool T1(M).t
val count :
'a e ->
f:('a -> bool T1(M).t) -> Monoid.Int.t T1(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b e -> f:('b -> 'a T1(M).t) -> 'a T1(M).t
val find :
'a e ->
f:('a -> bool T1(M).t) -> 'a Option.t T1(M).t
val find_map :
'a e ->
f:('a -> 'b Option.t T1(M).t) ->
'b Option.t T1(M).t
val filter :
'a e -> f:('a -> bool T1(M).t) -> 'a e T1(M).t
val filter_map :
'a e ->
f:('a -> 'b Option.t T1(M).t) -> 'b e T1(M).t
end
module Seq :
sig
val all :
'a T1(M).t Core_kernel.Std.Sequence.t ->
'a Core_kernel.Std.Sequence.t T1(M).t
val all_ignore :
'a T1(M).t Core_kernel.Std.Sequence.t ->
Monoid.Unit.t T1(M).t
val sequence :
Monoid.Unit.t T1(M).t Core_kernel.Std.Sequence.t ->
Monoid.Unit.t T1(M).t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b T1(M).t) ->
'b Core_kernel.Std.Sequence.t T1(M).t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> Monoid.Unit.t T1(M).t) ->
Monoid.Unit.t T1(M).t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> 'b T1(M).t) -> init:'b -> 'b T1(M).t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> 'a T1(M).t) -> 'a Option.t T1(M).t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(M).t) -> bool T1(M).t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(M).t) -> bool T1(M).t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(M).t) -> Monoid.Int.t T1(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> 'a T1(M).t) -> 'a T1(M).t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(M).t) -> 'a Option.t T1(M).t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b Option.t T1(M).t) ->
'b Option.t T1(M).t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(M).t) ->
'a Core_kernel.Std.Sequence.t T1(M).t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b Option.t T1(M).t) ->
'b Core_kernel.Std.Sequence.t T1(M).t
end
val ( >=> ) :
('a -> 'b T1(M).t) ->
('b -> 'c T1(M).t) -> 'a -> 'c T1(M).t
val ( !! ) : 'a -> 'a T1(M).t
val ( !$ ) : ('a -> 'b) -> 'a T1(M).t -> 'b T1(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
'a T1(M).t -> 'b T1(M).t -> 'c T1(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a T1(M).t -> 'b T1(M).t -> 'c T1(M).t -> 'd T1(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(M).t ->
'b T1(M).t -> 'c T1(M).t -> 'd T1(M).t -> 'e T1(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(M).t ->
'b T1(M).t ->
'c T1(M).t -> 'd T1(M).t -> 'e T1(M).t -> 'f T1(M).t
val ( >>= ) :
'a T1(M).t -> ('a -> 'b T1(M).t) -> 'b T1(M).t
val ( >>| ) : 'a T1(M).t -> ('a -> 'b) -> 'b T1(M).t
module Monad_infix :
sig
val ( >>= ) :
'a T1(M).t -> ('a -> 'b T1(M).t) -> 'b T1(M).t
val ( >>| ) : 'a T1(M).t -> ('a -> 'b) -> 'b T1(M).t
end
val bind :
'a T1(M).t -> f:('a -> 'b T1(M).t) -> 'b T1(M).t
val return : 'a -> 'a T1(M).t
val map : 'a T1(M).t -> f:('a -> 'b) -> 'b T1(M).t
val join : 'a T1(M).t T1(M).t -> 'a T1(M).t
val ignore_m : 'a T1(M).t -> Monoid.Unit.t T1(M).t
val all : 'a T1(M).t e -> 'a e T1(M).t
val all_ignore :
Monoid.Unit.t T1(M).t e -> Monoid.Unit.t T1(M).t
module Let_syntax :
sig
val return : 'a -> 'a T1(M).t
val ( >>= ) :
'a T1(M).t -> ('a -> 'b T1(M).t) -> 'b T1(M).t
val ( >>| ) : 'a T1(M).t -> ('a -> 'b) -> 'b T1(M).t
module Let_syntax :
sig
val return : 'a -> 'a T1(M).t
val bind :
'a T1(M).t ->
f:('a -> 'b T1(M).t) -> 'b T1(M).t
val map :
'a T1(M).t -> f:('a -> 'b) -> 'b T1(M).t
val both :
'a T1(M).t -> 'b T1(M).t -> ('a * 'b) T1(M).t
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) :
'a T1(M).t -> ('a -> 'b T1(M).t) -> 'b T1(M).t
val ( >>| ) : 'a T1(M).t -> ('a -> 'b) -> 'b T1(M).t
val ( >=> ) :
('a -> 'b T1(M).t) ->
('b -> 'c T1(M).t) -> 'a -> 'c T1(M).t
val ( !! ) : 'a -> 'a T1(M).t
val ( !$ ) : ('a -> 'b) -> 'a T1(M).t -> 'b T1(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
'a T1(M).t -> 'b T1(M).t -> 'c T1(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a T1(M).t ->
'b T1(M).t -> 'c T1(M).t -> 'd T1(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(M).t ->
'b T1(M).t ->
'c T1(M).t -> 'd T1(M).t -> 'e T1(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(M).t ->
'b T1(M).t ->
'c T1(M).t ->
'd T1(M).t -> 'e T1(M).t -> 'f T1(M).t
end
val pure : 'a -> 'a T1(M).t
val accept : 'a -> 'a T1(M).t
val reject : Monoid.Unit.t -> 'a T1(M).t
val guard : bool -> Monoid.Unit.t T1(M).t
val on :
bool -> Monoid.Unit.t T1(M).t -> Monoid.Unit.t T1(M).t
val unless :
bool -> Monoid.Unit.t T1(M).t -> Monoid.Unit.t T1(M).t
val zero : Monoid.Unit.t -> 'a T1(M).t
val plus : 'a T1(M).t -> 'a T1(M).t -> 'a T1(M).t
end
module T2 :
functor (M : Core_kernel.Std.T2) ->
sig
type ('a, 'e) t = ('a list, 'e) M.t
type ('a, 'e) m = ('a, 'e) M.t
type ('a, 'e) e = ('a, 'e) Monads.Std.Monad.List.T2.t
end
module Make2 :
functor (M : Monad2) ->
sig
val lift : ('a, 'e) M.t -> ('a, 'e) T2(M).t
val run :
('a, 'e) T2(M).t -> ('a, 'e) Monads.Std.Monad.List.T2.t
val void :
('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t e ->
(Monoid.Unit.t, 'e) T2(M).t
val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
module Fn :
sig
val id : 'a -> ('a, 'e) T2(M).t
val ignore :
('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
val nothing :
Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
val non :
('a -> (bool, 'e) T2(M).t) ->
'a -> (bool, 'e) T2(M).t
val apply_n_times :
n:Monoid.Int.t ->
('a -> ('a, 'e) T2(M).t) -> 'a -> ('a, 'e) T2(M).t
val compose :
('b -> ('c, 'e) T2(M).t) ->
('a -> ('b, 'e) T2(M).t) -> 'a -> ('c, 'e) T2(M).t
end
module Pair :
sig
val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
end
module Triple :
sig
val fst :
('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
val snd :
('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
val trd :
('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
end
module Lift :
sig
val nullary : 'a -> ('a, 'e) T2(M).t
val unary :
('a -> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
val binary :
('a -> 'b -> 'c) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
val ternary :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t ->
('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t -> ('e, 's) T2(M).t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t ->
('e, 's) T2(M).t -> ('f, 's) T2(M).t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t ->
(Monoid.Unit.t, 's) T2(M).t) ->
f:(Monoid.Unit.t -> ('a, 's) T2(M).t) ->
catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
end
module Collection :
sig
module type S =
sig
type 'a t
val all :
('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b t, 'e) T2(M).t
val iter :
'a t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val for_all :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val count :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t ->
f:('b -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
val find :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a t, 'e) T2(M).t
val filter_map :
'a t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b t, 'e) T2(M).t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all :
('a, 'e) T2(M).t T.t -> ('a T.t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a T.t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val count :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> ('a, 'e) T2(M).t) ->
('a, 'e) T2(M).t
val find :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a T.t, 'e) T2(M).t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all :
('a, 'e) T2(M).t T.t -> ('a T.t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a T.t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val count :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> ('a, 'e) T2(M).t) ->
('a, 'e) T2(M).t
val find :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a T.t, 'e) T2(M).t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
end
end
module List :
sig
val all : ('a, 'e) T2(M).t e -> ('a e, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t e -> (Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t e ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a e ->
f:('a -> ('b, 'e) T2(M).t) -> ('b e, 'e) T2(M).t
val iter :
'a e ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a e ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a e ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a e ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a e ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a e ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val for_all :
'a e ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val count :
'a e ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b e ->
f:('b -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
val find :
'a e ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a e ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a e ->
f:('a -> (bool, 'e) T2(M).t) -> ('a e, 'e) T2(M).t
val filter_map :
'a e ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b e, 'e) T2(M).t
end
module Seq :
sig
val all :
('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
('a Core_kernel.Std.Sequence.t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t
Core_kernel.Std.Sequence.t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b Core_kernel.Std.Sequence.t, 'e) T2(M).t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Core_kernel.Std.Sequence.t, 'e) T2(M).t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Core_kernel.Std.Sequence.t, 'e) T2(M).t
end
val ( >=> ) :
('a -> ('b, 'e) T2(M).t) ->
('b -> ('c, 'e) T2(M).t) -> 'a -> ('c, 'e) T2(M).t
val ( !! ) : 'a -> ('a, 'e) T2(M).t
val ( !$ ) :
('a -> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t ->
('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t -> ('e, 's) T2(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t ->
('e, 's) T2(M).t -> ('f, 's) T2(M).t
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) T2(M).t
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) T2(M).t
val bind :
('a, 'e) T2(M).t ->
f:('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val map :
('a, 'e) T2(M).t ->
f:('a -> 'b) -> ('b, 'e) T2(M).t
val both :
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
end
val bind :
('a, 'e) T2(M).t ->
f:('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val return : 'a -> ('a, 'b) T2(M).t
val map :
('a, 'e) T2(M).t -> f:('a -> 'b) -> ('b, 'e) T2(M).t
val join :
(('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
val ignore_m :
('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
val all : ('a, 'e) T2(M).t e -> ('a e, 'e) T2(M).t
val all_ignore :
(Monoid.Unit.t, 'e) T2(M).t e ->
(Monoid.Unit.t, 'e) T2(M).t
module Syntax :
sig
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
val ( >=> ) :
('a -> ('b, 'e) T2(M).t) ->
('b -> ('c, 'e) T2(M).t) -> 'a -> ('c, 'e) T2(M).t
val ( !! ) : 'a -> ('a, 'e) T2(M).t
val ( !$ ) :
('a -> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t ->
('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t -> ('e, 's) T2(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t ->
('e, 's) T2(M).t -> ('f, 's) T2(M).t
end
val pure : 'a -> ('a, 'e) T2(M).t
val accept : 'a -> ('a, 'e) T2(M).t
val reject : Monoid.Unit.t -> ('a, 'e) T2(M).t
val guard : bool -> (Monoid.Unit.t, 'e) T2(M).t
val on :
bool ->
(Monoid.Unit.t, 'e) T2(M).t ->
(Monoid.Unit.t, 'e) T2(M).t
val unless :
bool ->
(Monoid.Unit.t, 'e) T2(M).t ->
(Monoid.Unit.t, 'e) T2(M).t
val zero : Monoid.Unit.t -> ('a, 'e) T2(M).t
val plus :
('a, 'e) T2(M).t ->
('a, 'e) T2(M).t -> ('a, 'e) T2(M).t
end
end
module Seq :
sig
module type S =
sig
type 'a t
type 'a m
type 'a e
val lift : 'a m -> 'a t
val run : 'a t -> 'a e
val void : 'a t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
val forever : 'a t -> 'b t
module Fn :
sig
val id : 'a -> 'a t
val ignore : 'a t -> Monoid.Unit.t t
val nothing : Monoid.Unit.t -> Monoid.Unit.t t
val non : ('a -> bool t) -> 'a -> bool t
val apply_n_times :
n:Monoid.Int.t -> ('a -> 'a t) -> 'a -> 'a t
val compose :
('b -> 'c t) -> ('a -> 'b t) -> 'a -> 'c t
end
module Pair :
sig
val fst : ('a * 'b) t -> 'a t
val snd : ('a * 'b) t -> 'b t
end
module Triple :
sig
val fst : ('a * 'b * 'c) t -> 'a t
val snd : ('a * 'b * 'c) t -> 'b t
val trd : ('a * 'b * 'c) t -> 'c t
end
module Lift :
sig
val nullary : 'a -> 'a t
val unary : ('a -> 'b) -> 'a t -> 'b t
val binary : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ternary :
('a -> 'b -> 'c -> 'd) ->
'a t -> 'b t -> 'c t -> 'd t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
f:(Monoid.Unit.t -> 'a t) ->
catch:(exn -> 'a t) -> 'a t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a t t -> 'a t t
val all_ignore : 'a t t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
val map : 'a t -> f:('a -> 'b t) -> 'b t t
val iter :
'a t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a t -> f:('a -> bool t) -> bool t
val for_all : 'a t -> f:('a -> bool t) -> bool t
val count :
'a t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> 'a t) -> 'a t
val find :
'a t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a t -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter : 'a t -> f:('a -> bool t) -> 'a t t
val filter_map :
'a t -> f:('a -> 'b Option.t t) -> 'b t t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a T.t -> f:('a -> bool t) -> bool t
val for_all :
'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a T.t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t -> f:('a -> 'b Option.t t) -> 'b T.t t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a T.t -> f:('a -> bool t) -> bool t
val for_all :
'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a T.t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t -> f:('a -> 'b Option.t t) -> 'b T.t t
end
end
module List :
sig
val all : 'a t List.t -> 'a List.t t
val all_ignore : 'a t List.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t List.t -> Monoid.Unit.t t
val map : 'a List.t -> f:('a -> 'b t) -> 'b List.t t
val iter :
'a List.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a List.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a List.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a List.t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a List.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a List.t -> f:('a -> bool t) -> bool t
val for_all : 'a List.t -> f:('a -> bool t) -> bool t
val count :
'a List.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b List.t -> f:('b -> 'a t) -> 'a t
val find :
'a List.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a List.t -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a List.t -> f:('a -> bool t) -> 'a List.t t
val filter_map :
'a List.t -> f:('a -> 'b Option.t t) -> 'b List.t t
end
module Seq :
sig
val all :
'a t Core_kernel.Std.Sequence.t ->
'a Core_kernel.Std.Sequence.t t
val all_ignore :
'a t Core_kernel.Std.Sequence.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t Core_kernel.Std.Sequence.t ->
Monoid.Unit.t t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b t) -> 'b Core_kernel.Std.Sequence.t t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> bool t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> bool t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> 'a t) -> 'a t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> 'a Option.t t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool t) -> 'a Core_kernel.Std.Sequence.t t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b Option.t t) ->
'b Core_kernel.Std.Sequence.t t
end
val ( >=> ) : ('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Monad_infix :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
end
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val return : 'a -> 'a t
val map : 'a t -> f:('a -> 'b) -> 'b t
val join : 'a t t -> 'a t
val ignore_m : 'a t -> Monoid.Unit.t t
val all : 'a t list -> 'a list t
val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
module Let_syntax :
sig
val return : 'a -> 'a t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Let_syntax :
sig
val return : 'a -> 'a t
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val map : 'a t -> f:('a -> 'b) -> 'b t
val both : 'a t -> 'b t -> ('a * 'b) t
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
val ( >=> ) :
('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
val pure : 'a -> 'a t
val accept : 'a -> 'a t
val reject : Monoid.Unit.t -> 'a t
val guard : bool -> Monoid.Unit.t t
val on : bool -> Monoid.Unit.t t -> Monoid.Unit.t t
val unless : bool -> Monoid.Unit.t t -> Monoid.Unit.t t
val zero : Monoid.Unit.t -> 'a t
val plus : 'a t -> 'a t -> 'a t
end
module type S2 =
sig
type ('a, 'e) t
type ('a, 'e) m
type ('a, 'e) e
val lift : ('a, 'e) m -> ('a, 'e) t
val run : ('a, 'e) t -> ('a, 'e) e
val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
val forever : ('a, 'e) t -> ('b, 'e) t
module Fn :
sig
val id : 'a -> ('a, 'e) t
val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
val non : ('a -> (bool, 'e) t) -> 'a -> (bool, 'e) t
val apply_n_times :
n:Monoid.Int.t ->
('a -> ('a, 'e) t) -> 'a -> ('a, 'e) t
val compose :
('b -> ('c, 'e) t) ->
('a -> ('b, 'e) t) -> 'a -> ('c, 'e) t
end
module Pair :
sig
val fst : ('a * 'b, 'e) t -> ('a, 'e) t
val snd : ('a * 'b, 'e) t -> ('b, 'e) t
end
module Triple :
sig
val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
end
module Lift :
sig
val nullary : 'a -> ('a, 'e) t
val unary : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val binary :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ternary :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
f:(Monoid.Unit.t -> ('a, 's) t) ->
catch:(exn -> ('a, 's) t) -> ('a, 's) t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : ('a, 'e) t t -> ('a t, 'e) t
val all_ignore :
('a, 'e) t t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
val map :
'a t -> f:('a -> ('b, 'e) t) -> ('b t, 'e) t
val iter :
'a t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a t -> f:('a -> (bool, 'e) t) -> ('a t, 'e) t
val filter_map :
'a t ->
f:('a -> ('b Option.t, 'e) t) -> ('b t, 'e) t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : ('a, 'e) t T.t -> ('a T.t, 'e) t
val all_ignore :
('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t T.t ->
(Monoid.Unit.t, 'e) t
val map :
'a T.t ->
f:('a -> ('b, 'e) t) -> ('b T.t, 'e) t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) t) ->
('a Option.t, 'e) t
val exists :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a T.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a T.t, 'e) t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b T.t, 'e) t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : ('a, 'e) t T.t -> ('a T.t, 'e) t
val all_ignore :
('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t T.t ->
(Monoid.Unit.t, 'e) t
val map :
'a T.t ->
f:('a -> ('b, 'e) t) -> ('b T.t, 'e) t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) t) ->
('a Option.t, 'e) t
val exists :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a T.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a T.t, 'e) t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b T.t, 'e) t
end
end
module List :
sig
val all : ('a, 'e) t List.t -> ('a List.t, 'e) t
val all_ignore :
('a, 'e) t List.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
val map :
'a List.t ->
f:('a -> ('b, 'e) t) -> ('b List.t, 'e) t
val iter :
'a List.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a List.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a List.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a List.t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a List.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a List.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a List.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a List.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b List.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a List.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a List.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b Option.t, 'e) t
val filter :
'a List.t ->
f:('a -> (bool, 'e) t) -> ('a List.t, 'e) t
val filter_map :
'a List.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b List.t, 'e) t
end
module Seq :
sig
val all :
('a, 'e) t Core_kernel.Std.Sequence.t ->
('a Core_kernel.Std.Sequence.t, 'e) t
val all_ignore :
('a, 'e) t Core_kernel.Std.Sequence.t ->
(Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t Core_kernel.Std.Sequence.t ->
(Monoid.Unit.t, 'e) t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b, 'e) t) ->
('b Core_kernel.Std.Sequence.t, 'e) t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b Option.t, 'e) t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) t) ->
('a Core_kernel.Std.Sequence.t, 'e) t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Core_kernel.Std.Sequence.t, 'e) t
end
val ( >=> ) :
('a -> ('b, 'e) t) ->
('b -> ('c, 'e) t) -> 'a -> ('c, 'e) t
val ( !! ) : 'a -> ('a, 'e) t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val bind :
('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val both :
('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
end
val bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val return : 'a -> ('a, 'b) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore :
(Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
module Syntax :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
val ( >=> ) :
('a -> ('b, 'e) t) ->
('b -> ('c, 'e) t) -> 'a -> ('c, 'e) t
val ( !! ) : 'a -> ('a, 'e) t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
end
val pure : 'a -> ('a, 'e) t
val accept : 'a -> ('a, 'e) t
val reject : Monoid.Unit.t -> ('a, 'e) t
val guard : bool -> (Monoid.Unit.t, 'e) t
val on :
bool -> (Monoid.Unit.t, 'e) t -> (Monoid.Unit.t, 'e) t
val unless :
bool -> (Monoid.Unit.t, 'e) t -> (Monoid.Unit.t, 'e) t
val zero : Monoid.Unit.t -> ('a, 'e) t
val plus : ('a, 'e) t -> ('a, 'e) t -> ('a, 'e) t
end
type 'a t = 'a Core_kernel.Std.Sequence.t
type 'a m = 'a
type 'a e = 'a t
val lift : 'a -> 'a e
val run : 'a e -> 'a e
val void : 'a e -> Monoid.Unit.t e
val sequence : Monoid.Unit.t e List.t -> Monoid.Unit.t e
val forever : 'a e -> 'b e
module Fn :
sig
val id : 'a -> 'a e
val ignore : 'a e -> Monoid.Unit.t e
val nothing : Monoid.Unit.t -> Monoid.Unit.t e
val non : ('a -> bool e) -> 'a -> bool e
val apply_n_times :
n:Monoid.Int.t -> ('a -> 'a e) -> 'a -> 'a e
val compose : ('b -> 'c e) -> ('a -> 'b e) -> 'a -> 'c e
end
module Pair :
sig
val fst : ('a * 'b) e -> 'a e
val snd : ('a * 'b) e -> 'b e
end
module Triple :
sig
val fst : ('a * 'b * 'c) e -> 'a e
val snd : ('a * 'b * 'c) e -> 'b e
val trd : ('a * 'b * 'c) e -> 'c e
end
module Lift :
sig
val nullary : 'a -> 'a e
val unary : ('a -> 'b) -> 'a e -> 'b e
val binary : ('a -> 'b -> 'c) -> 'a e -> 'b e -> 'c e
val ternary :
('a -> 'b -> 'c -> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a e -> 'b e -> 'c e -> 'd e -> 'e e
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t e) ->
f:(Monoid.Unit.t -> 'a e) -> catch:(exn -> 'a e) -> 'a e
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a e t -> 'a t e
val all_ignore : 'a e t -> Monoid.Unit.t e
val sequence : Monoid.Unit.t e t -> Monoid.Unit.t e
val map : 'a t -> f:('a -> 'b e) -> 'b t e
val iter :
'a t -> f:('a -> Monoid.Unit.t e) -> Monoid.Unit.t e
val fold :
'a t -> init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_left :
'a t -> init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_right :
'a t -> f:('a -> 'b -> 'b e) -> init:'b -> 'b e
val reduce :
'a t -> f:('a -> 'a -> 'a e) -> 'a Option.t e
val exists : 'a t -> f:('a -> bool e) -> bool e
val for_all : 'a t -> f:('a -> bool e) -> bool e
val count : 'a t -> f:('a -> bool e) -> Monoid.Int.t e
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> 'a e) -> 'a e
val find : 'a t -> f:('a -> bool e) -> 'a Option.t e
val find_map :
'a t -> f:('a -> 'b Option.t e) -> 'b Option.t e
val filter : 'a t -> f:('a -> bool e) -> 'a t e
val filter_map :
'a t -> f:('a -> 'b Option.t e) -> 'b t e
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : 'a e T.t -> 'a T.t e
val all_ignore : 'a e T.t -> Monoid.Unit.t e
val sequence : Monoid.Unit.t e T.t -> Monoid.Unit.t e
val map : 'a T.t -> f:('a -> 'b e) -> 'b T.t e
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t e) -> Monoid.Unit.t e
val fold :
'a T.t -> init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_left :
'a T.t -> init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_right :
'a T.t -> f:('a -> 'b -> 'b e) -> init:'b -> 'b e
val reduce :
'a T.t -> f:('a -> 'a -> 'a e) -> 'a Option.t e
val exists : 'a T.t -> f:('a -> bool e) -> bool e
val for_all : 'a T.t -> f:('a -> bool e) -> bool e
val count :
'a T.t -> f:('a -> bool e) -> Monoid.Int.t e
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a e) -> 'a e
val find :
'a T.t -> f:('a -> bool e) -> 'a Option.t e
val find_map :
'a T.t -> f:('a -> 'b Option.t e) -> 'b Option.t e
val filter : 'a T.t -> f:('a -> bool e) -> 'a T.t e
val filter_map :
'a T.t -> f:('a -> 'b Option.t e) -> 'b T.t e
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : 'a e T.t -> 'a T.t e
val all_ignore : 'a e T.t -> Monoid.Unit.t e
val sequence : Monoid.Unit.t e T.t -> Monoid.Unit.t e
val map : 'a T.t -> f:('a -> 'b e) -> 'b T.t e
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t e) -> Monoid.Unit.t e
val fold :
'a T.t -> init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_left :
'a T.t -> init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_right :
'a T.t -> f:('a -> 'b -> 'b e) -> init:'b -> 'b e
val reduce :
'a T.t -> f:('a -> 'a -> 'a e) -> 'a Option.t e
val exists : 'a T.t -> f:('a -> bool e) -> bool e
val for_all : 'a T.t -> f:('a -> bool e) -> bool e
val count :
'a T.t -> f:('a -> bool e) -> Monoid.Int.t e
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a e) -> 'a e
val find :
'a T.t -> f:('a -> bool e) -> 'a Option.t e
val find_map :
'a T.t -> f:('a -> 'b Option.t e) -> 'b Option.t e
val filter : 'a T.t -> f:('a -> bool e) -> 'a T.t e
val filter_map :
'a T.t -> f:('a -> 'b Option.t e) -> 'b T.t e
end
end
module List :
sig
val all : 'a e List.t -> 'a List.t e
val all_ignore : 'a e List.t -> Monoid.Unit.t e
val sequence : Monoid.Unit.t e List.t -> Monoid.Unit.t e
val map : 'a List.t -> f:('a -> 'b e) -> 'b List.t e
val iter :
'a List.t -> f:('a -> Monoid.Unit.t e) -> Monoid.Unit.t e
val fold :
'a List.t -> init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_left :
'a List.t -> init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_right :
'a List.t -> f:('a -> 'b -> 'b e) -> init:'b -> 'b e
val reduce :
'a List.t -> f:('a -> 'a -> 'a e) -> 'a Option.t e
val exists : 'a List.t -> f:('a -> bool e) -> bool e
val for_all : 'a List.t -> f:('a -> bool e) -> bool e
val count : 'a List.t -> f:('a -> bool e) -> Monoid.Int.t e
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b List.t -> f:('b -> 'a e) -> 'a e
val find : 'a List.t -> f:('a -> bool e) -> 'a Option.t e
val find_map :
'a List.t -> f:('a -> 'b Option.t e) -> 'b Option.t e
val filter : 'a List.t -> f:('a -> bool e) -> 'a List.t e
val filter_map :
'a List.t -> f:('a -> 'b Option.t e) -> 'b List.t e
end
module Seq :
sig
val all : 'a e e -> 'a e e
val all_ignore : 'a e e -> Monoid.Unit.t e
val sequence : Monoid.Unit.t e e -> Monoid.Unit.t e
val map : 'a e -> f:('a -> 'b e) -> 'b e e
val iter :
'a e -> f:('a -> Monoid.Unit.t e) -> Monoid.Unit.t e
val fold : 'a e -> init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_left :
'a e -> init:'b -> f:('b -> 'a -> 'b e) -> 'b e
val fold_right :
'a e -> f:('a -> 'b -> 'b e) -> init:'b -> 'b e
val reduce : 'a e -> f:('a -> 'a -> 'a e) -> 'a Option.t e
val exists : 'a e -> f:('a -> bool e) -> bool e
val for_all : 'a e -> f:('a -> bool e) -> bool e
val count : 'a e -> f:('a -> bool e) -> Monoid.Int.t e
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b e -> f:('b -> 'a e) -> 'a e
val find : 'a e -> f:('a -> bool e) -> 'a Option.t e
val find_map :
'a e -> f:('a -> 'b Option.t e) -> 'b Option.t e
val filter : 'a e -> f:('a -> bool e) -> 'a e e
val filter_map : 'a e -> f:('a -> 'b Option.t e) -> 'b e e
end
val ( >=> ) : ('a -> 'b e) -> ('b -> 'c e) -> 'a -> 'c e
val ( !! ) : 'a -> 'a e
val ( !$ ) : ('a -> 'b) -> 'a e -> 'b e
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a e -> 'b e -> 'c e
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a e -> 'b e -> 'c e -> 'd e -> 'e e
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
val ( >>= ) : 'a e -> ('a -> 'b e) -> 'b e
val ( >>| ) : 'a e -> ('a -> 'b) -> 'b e
module Monad_infix :
sig
val ( >>= ) : 'a e -> ('a -> 'b e) -> 'b e
val ( >>| ) : 'a e -> ('a -> 'b) -> 'b e
end
val bind : 'a e -> f:('a -> 'b e) -> 'b e
val return : 'a -> 'a e
val map : 'a e -> f:('a -> 'b) -> 'b e
val join : 'a e e -> 'a e
val ignore_m : 'a e -> Monoid.Unit.t e
val all : 'a e list -> 'a list e
val all_ignore : Monoid.Unit.t e list -> Monoid.Unit.t e
module Let_syntax :
sig
val return : 'a -> 'a e
val ( >>= ) : 'a e -> ('a -> 'b e) -> 'b e
val ( >>| ) : 'a e -> ('a -> 'b) -> 'b e
module Let_syntax :
sig
val return : 'a -> 'a e
val bind : 'a e -> f:('a -> 'b e) -> 'b e
val map : 'a e -> f:('a -> 'b) -> 'b e
val both : 'a e -> 'b e -> ('a * 'b) e
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) : 'a e -> ('a -> 'b e) -> 'b e
val ( >>| ) : 'a e -> ('a -> 'b) -> 'b e
val ( >=> ) : ('a -> 'b e) -> ('b -> 'c e) -> 'a -> 'c e
val ( !! ) : 'a -> 'a e
val ( !$ ) : ('a -> 'b) -> 'a e -> 'b e
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a e -> 'b e -> 'c e
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a e -> 'b e -> 'c e -> 'd e -> 'e e
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
end
val pure : 'a -> 'a e
val accept : 'a -> 'a e
val reject : Monoid.Unit.t -> 'a e
val guard : bool -> Monoid.Unit.t e
val on : bool -> Monoid.Unit.t e -> Monoid.Unit.t e
val unless : bool -> Monoid.Unit.t e -> Monoid.Unit.t e
val zero : Monoid.Unit.t -> 'a e
val plus : 'a e -> 'a e -> 'a e
module T1 :
functor (M : Core_kernel.Std.T1) ->
sig
type 'a t = 'a Core_kernel.Std.Sequence.t M.t
type 'a m = 'a M.t
type 'a e = 'a Monads.Std.Monad.Seq.T1.t
end
module Make :
functor (M : Monad) ->
sig
val lift : 'a M.t -> 'a T1(M).t
val run : 'a T1(M).t -> 'a Monads.Std.Monad.Seq.T1.t
val void : 'a T1(M).t -> Monoid.Unit.t T1(M).t
val sequence :
Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
val forever : 'a T1(M).t -> 'b T1(M).t
module Fn :
sig
val id : 'a -> 'a T1(M).t
val ignore : 'a T1(M).t -> Monoid.Unit.t T1(M).t
val nothing : Monoid.Unit.t -> Monoid.Unit.t T1(M).t
val non : ('a -> bool T1(M).t) -> 'a -> bool T1(M).t
val apply_n_times :
n:Monoid.Int.t ->
('a -> 'a T1(M).t) -> 'a -> 'a T1(M).t
val compose :
('b -> 'c T1(M).t) ->
('a -> 'b T1(M).t) -> 'a -> 'c T1(M).t
end
module Pair :
sig
val fst : ('a * 'b) T1(M).t -> 'a T1(M).t
val snd : ('a * 'b) T1(M).t -> 'b T1(M).t
end
module Triple :
sig
val fst : ('a * 'b * 'c) T1(M).t -> 'a T1(M).t
val snd : ('a * 'b * 'c) T1(M).t -> 'b T1(M).t
val trd : ('a * 'b * 'c) T1(M).t -> 'c T1(M).t
end
module Lift :
sig
val nullary : 'a -> 'a T1(M).t
val unary : ('a -> 'b) -> 'a T1(M).t -> 'b T1(M).t
val binary :
('a -> 'b -> 'c) ->
'a T1(M).t -> 'b T1(M).t -> 'c T1(M).t
val ternary :
('a -> 'b -> 'c -> 'd) ->
'a T1(M).t ->
'b T1(M).t -> 'c T1(M).t -> 'd T1(M).t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(M).t ->
'b T1(M).t ->
'c T1(M).t -> 'd T1(M).t -> 'e T1(M).t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(M).t ->
'b T1(M).t ->
'c T1(M).t ->
'd T1(M).t -> 'e T1(M).t -> 'f T1(M).t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t T1(M).t) ->
f:(Monoid.Unit.t -> 'a T1(M).t) ->
catch:(exn -> 'a T1(M).t) -> 'a T1(M).t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a T1(M).t t -> 'a t T1(M).t
val all_ignore :
'a T1(M).t t -> Monoid.Unit.t T1(M).t
val sequence :
Monoid.Unit.t T1(M).t t ->
Monoid.Unit.t T1(M).t
val map :
'a t -> f:('a -> 'b T1(M).t) -> 'b t T1(M).t
val iter :
'a t ->
f:('a -> Monoid.Unit.t T1(M).t) ->
Monoid.Unit.t T1(M).t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_right :
'a t ->
f:('a -> 'b -> 'b T1(M).t) ->
init:'b -> 'b T1(M).t
val reduce :
'a t ->
f:('a -> 'a -> 'a T1(M).t) ->
'a Option.t T1(M).t
val exists :
'a t -> f:('a -> bool T1(M).t) -> bool T1(M).t
val for_all :
'a t -> f:('a -> bool T1(M).t) -> bool T1(M).t
val count :
'a t ->
f:('a -> bool T1(M).t) -> Monoid.Int.t T1(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> 'a T1(M).t) -> 'a T1(M).t
val find :
'a t ->
f:('a -> bool T1(M).t) -> 'a Option.t T1(M).t
val find_map :
'a t ->
f:('a -> 'b Option.t T1(M).t) ->
'b Option.t T1(M).t
val filter :
'a t -> f:('a -> bool T1(M).t) -> 'a t T1(M).t
val filter_map :
'a t ->
f:('a -> 'b Option.t T1(M).t) -> 'b t T1(M).t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : 'a T1(M).t T.t -> 'a T.t T1(M).t
val all_ignore :
'a T1(M).t T.t -> Monoid.Unit.t T1(M).t
val sequence :
Monoid.Unit.t T1(M).t T.t ->
Monoid.Unit.t T1(M).t
val map :
'a T.t ->
f:('a -> 'b T1(M).t) -> 'b T.t T1(M).t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t T1(M).t) ->
Monoid.Unit.t T1(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b T1(M).t) ->
init:'b -> 'b T1(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> 'a T1(M).t) ->
'a Option.t T1(M).t
val exists :
'a T.t ->
f:('a -> bool T1(M).t) -> bool T1(M).t
val for_all :
'a T.t ->
f:('a -> bool T1(M).t) -> bool T1(M).t
val count :
'a T.t ->
f:('a -> bool T1(M).t) ->
Monoid.Int.t T1(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a T1(M).t) -> 'a T1(M).t
val find :
'a T.t ->
f:('a -> bool T1(M).t) -> 'a Option.t T1(M).t
val find_map :
'a T.t ->
f:('a -> 'b Option.t T1(M).t) ->
'b Option.t T1(M).t
val filter :
'a T.t ->
f:('a -> bool T1(M).t) -> 'a T.t T1(M).t
val filter_map :
'a T.t ->
f:('a -> 'b Option.t T1(M).t) ->
'b T.t T1(M).t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : 'a T1(M).t T.t -> 'a T.t T1(M).t
val all_ignore :
'a T1(M).t T.t -> Monoid.Unit.t T1(M).t
val sequence :
Monoid.Unit.t T1(M).t T.t ->
Monoid.Unit.t T1(M).t
val map :
'a T.t ->
f:('a -> 'b T1(M).t) -> 'b T.t T1(M).t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t T1(M).t) ->
Monoid.Unit.t T1(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b T1(M).t) ->
init:'b -> 'b T1(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> 'a T1(M).t) ->
'a Option.t T1(M).t
val exists :
'a T.t ->
f:('a -> bool T1(M).t) -> bool T1(M).t
val for_all :
'a T.t ->
f:('a -> bool T1(M).t) -> bool T1(M).t
val count :
'a T.t ->
f:('a -> bool T1(M).t) ->
Monoid.Int.t T1(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a T1(M).t) -> 'a T1(M).t
val find :
'a T.t ->
f:('a -> bool T1(M).t) -> 'a Option.t T1(M).t
val find_map :
'a T.t ->
f:('a -> 'b Option.t T1(M).t) ->
'b Option.t T1(M).t
val filter :
'a T.t ->
f:('a -> bool T1(M).t) -> 'a T.t T1(M).t
val filter_map :
'a T.t ->
f:('a -> 'b Option.t T1(M).t) ->
'b T.t T1(M).t
end
end
module List :
sig
val all : 'a T1(M).t list -> 'a list T1(M).t
val all_ignore :
'a T1(M).t list -> Monoid.Unit.t T1(M).t
val sequence :
Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
val map :
'a list -> f:('a -> 'b T1(M).t) -> 'b list T1(M).t
val iter :
'a list ->
f:('a -> Monoid.Unit.t T1(M).t) ->
Monoid.Unit.t T1(M).t
val fold :
'a list ->
init:'b -> f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_left :
'a list ->
init:'b -> f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_right :
'a list ->
f:('a -> 'b -> 'b T1(M).t) -> init:'b -> 'b T1(M).t
val reduce :
'a list ->
f:('a -> 'a -> 'a T1(M).t) -> 'a Option.t T1(M).t
val exists :
'a list -> f:('a -> bool T1(M).t) -> bool T1(M).t
val for_all :
'a list -> f:('a -> bool T1(M).t) -> bool T1(M).t
val count :
'a list ->
f:('a -> bool T1(M).t) -> Monoid.Int.t T1(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list -> f:('b -> 'a T1(M).t) -> 'a T1(M).t
val find :
'a list ->
f:('a -> bool T1(M).t) -> 'a Option.t T1(M).t
val find_map :
'a list ->
f:('a -> 'b Option.t T1(M).t) ->
'b Option.t T1(M).t
val filter :
'a list ->
f:('a -> bool T1(M).t) -> 'a list T1(M).t
val filter_map :
'a list ->
f:('a -> 'b Option.t T1(M).t) -> 'b list T1(M).t
end
module Seq :
sig
val all : 'a T1(M).t e -> 'a e T1(M).t
val all_ignore :
'a T1(M).t e -> Monoid.Unit.t T1(M).t
val sequence :
Monoid.Unit.t T1(M).t e -> Monoid.Unit.t T1(M).t
val map :
'a e -> f:('a -> 'b T1(M).t) -> 'b e T1(M).t
val iter :
'a e ->
f:('a -> Monoid.Unit.t T1(M).t) ->
Monoid.Unit.t T1(M).t
val fold :
'a e ->
init:'b -> f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_left :
'a e ->
init:'b -> f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_right :
'a e ->
f:('a -> 'b -> 'b T1(M).t) -> init:'b -> 'b T1(M).t
val reduce :
'a e ->
f:('a -> 'a -> 'a T1(M).t) -> 'a Option.t T1(M).t
val exists :
'a e -> f:('a -> bool T1(M).t) -> bool T1(M).t
val for_all :
'a e -> f:('a -> bool T1(M).t) -> bool T1(M).t
val count :
'a e ->
f:('a -> bool T1(M).t) -> Monoid.Int.t T1(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b e -> f:('b -> 'a T1(M).t) -> 'a T1(M).t
val find :
'a e ->
f:('a -> bool T1(M).t) -> 'a Option.t T1(M).t
val find_map :
'a e ->
f:('a -> 'b Option.t T1(M).t) ->
'b Option.t T1(M).t
val filter :
'a e -> f:('a -> bool T1(M).t) -> 'a e T1(M).t
val filter_map :
'a e ->
f:('a -> 'b Option.t T1(M).t) -> 'b e T1(M).t
end
val ( >=> ) :
('a -> 'b T1(M).t) ->
('b -> 'c T1(M).t) -> 'a -> 'c T1(M).t
val ( !! ) : 'a -> 'a T1(M).t
val ( !$ ) : ('a -> 'b) -> 'a T1(M).t -> 'b T1(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
'a T1(M).t -> 'b T1(M).t -> 'c T1(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a T1(M).t -> 'b T1(M).t -> 'c T1(M).t -> 'd T1(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(M).t ->
'b T1(M).t -> 'c T1(M).t -> 'd T1(M).t -> 'e T1(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(M).t ->
'b T1(M).t ->
'c T1(M).t -> 'd T1(M).t -> 'e T1(M).t -> 'f T1(M).t
val ( >>= ) :
'a T1(M).t -> ('a -> 'b T1(M).t) -> 'b T1(M).t
val ( >>| ) : 'a T1(M).t -> ('a -> 'b) -> 'b T1(M).t
module Monad_infix :
sig
val ( >>= ) :
'a T1(M).t -> ('a -> 'b T1(M).t) -> 'b T1(M).t
val ( >>| ) : 'a T1(M).t -> ('a -> 'b) -> 'b T1(M).t
end
val bind :
'a T1(M).t -> f:('a -> 'b T1(M).t) -> 'b T1(M).t
val return : 'a -> 'a T1(M).t
val map : 'a T1(M).t -> f:('a -> 'b) -> 'b T1(M).t
val join : 'a T1(M).t T1(M).t -> 'a T1(M).t
val ignore_m : 'a T1(M).t -> Monoid.Unit.t T1(M).t
val all : 'a T1(M).t list -> 'a list T1(M).t
val all_ignore :
Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
module Let_syntax :
sig
val return : 'a -> 'a T1(M).t
val ( >>= ) :
'a T1(M).t -> ('a -> 'b T1(M).t) -> 'b T1(M).t
val ( >>| ) : 'a T1(M).t -> ('a -> 'b) -> 'b T1(M).t
module Let_syntax :
sig
val return : 'a -> 'a T1(M).t
val bind :
'a T1(M).t ->
f:('a -> 'b T1(M).t) -> 'b T1(M).t
val map :
'a T1(M).t -> f:('a -> 'b) -> 'b T1(M).t
val both :
'a T1(M).t -> 'b T1(M).t -> ('a * 'b) T1(M).t
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) :
'a T1(M).t -> ('a -> 'b T1(M).t) -> 'b T1(M).t
val ( >>| ) : 'a T1(M).t -> ('a -> 'b) -> 'b T1(M).t
val ( >=> ) :
('a -> 'b T1(M).t) ->
('b -> 'c T1(M).t) -> 'a -> 'c T1(M).t
val ( !! ) : 'a -> 'a T1(M).t
val ( !$ ) : ('a -> 'b) -> 'a T1(M).t -> 'b T1(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
'a T1(M).t -> 'b T1(M).t -> 'c T1(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a T1(M).t ->
'b T1(M).t -> 'c T1(M).t -> 'd T1(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(M).t ->
'b T1(M).t ->
'c T1(M).t -> 'd T1(M).t -> 'e T1(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(M).t ->
'b T1(M).t ->
'c T1(M).t ->
'd T1(M).t -> 'e T1(M).t -> 'f T1(M).t
end
val pure : 'a -> 'a T1(M).t
val accept : 'a -> 'a T1(M).t
val reject : Monoid.Unit.t -> 'a T1(M).t
val guard : bool -> Monoid.Unit.t T1(M).t
val on :
bool -> Monoid.Unit.t T1(M).t -> Monoid.Unit.t T1(M).t
val unless :
bool -> Monoid.Unit.t T1(M).t -> Monoid.Unit.t T1(M).t
val zero : Monoid.Unit.t -> 'a T1(M).t
val plus : 'a T1(M).t -> 'a T1(M).t -> 'a T1(M).t
end
module T2 :
functor (M : Core_kernel.Std.T2) ->
sig
type ('a, 'e) t = ('a Core_kernel.Std.Sequence.t, 'e) M.t
type ('a, 'e) m = ('a, 'e) M.t
type ('a, 'e) e = ('a, 'e) Monads.Std.Monad.Seq.T2.t
end
module Make2 :
functor (M : Monad2) ->
sig
val lift : ('a, 'e) M.t -> ('a, 'e) T2(M).t
val run :
('a, 'e) T2(M).t -> ('a, 'e) Monads.Std.Monad.Seq.T2.t
val void :
('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
module Fn :
sig
val id : 'a -> ('a, 'e) T2(M).t
val ignore :
('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
val nothing :
Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
val non :
('a -> (bool, 'e) T2(M).t) ->
'a -> (bool, 'e) T2(M).t
val apply_n_times :
n:Monoid.Int.t ->
('a -> ('a, 'e) T2(M).t) -> 'a -> ('a, 'e) T2(M).t
val compose :
('b -> ('c, 'e) T2(M).t) ->
('a -> ('b, 'e) T2(M).t) -> 'a -> ('c, 'e) T2(M).t
end
module Pair :
sig
val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
end
module Triple :
sig
val fst :
('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
val snd :
('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
val trd :
('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
end
module Lift :
sig
val nullary : 'a -> ('a, 'e) T2(M).t
val unary :
('a -> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
val binary :
('a -> 'b -> 'c) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
val ternary :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t ->
('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t -> ('e, 's) T2(M).t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t ->
('e, 's) T2(M).t -> ('f, 's) T2(M).t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t ->
(Monoid.Unit.t, 's) T2(M).t) ->
f:(Monoid.Unit.t -> ('a, 's) T2(M).t) ->
catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
end
module Collection :
sig
module type S =
sig
type 'a t
val all :
('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b t, 'e) T2(M).t
val iter :
'a t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val for_all :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val count :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t ->
f:('b -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
val find :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a t, 'e) T2(M).t
val filter_map :
'a t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b t, 'e) T2(M).t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all :
('a, 'e) T2(M).t T.t -> ('a T.t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a T.t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val count :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> ('a, 'e) T2(M).t) ->
('a, 'e) T2(M).t
val find :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a T.t, 'e) T2(M).t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all :
('a, 'e) T2(M).t T.t -> ('a T.t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a T.t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val count :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> ('a, 'e) T2(M).t) ->
('a, 'e) T2(M).t
val find :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a T.t, 'e) T2(M).t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
end
end
module List :
sig
val all :
('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a list ->
f:('a -> ('b, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
val iter :
'a list ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a list ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a list ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a list ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a list ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a list ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val for_all :
'a list ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val count :
'a list ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list ->
f:('b -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
val find :
'a list ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a list ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a list ->
f:('a -> (bool, 'e) T2(M).t) ->
('a list, 'e) T2(M).t
val filter_map :
'a list ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b list, 'e) T2(M).t
end
module Seq :
sig
val all : ('a, 'e) T2(M).t e -> ('a e, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t e -> (Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t e ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a e ->
f:('a -> ('b, 'e) T2(M).t) -> ('b e, 'e) T2(M).t
val iter :
'a e ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a e ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a e ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a e ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a e ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a e ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val for_all :
'a e ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val count :
'a e ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b e ->
f:('b -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
val find :
'a e ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a e ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a e ->
f:('a -> (bool, 'e) T2(M).t) -> ('a e, 'e) T2(M).t
val filter_map :
'a e ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b e, 'e) T2(M).t
end
val ( >=> ) :
('a -> ('b, 'e) T2(M).t) ->
('b -> ('c, 'e) T2(M).t) -> 'a -> ('c, 'e) T2(M).t
val ( !! ) : 'a -> ('a, 'e) T2(M).t
val ( !$ ) :
('a -> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t ->
('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t -> ('e, 's) T2(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t ->
('e, 's) T2(M).t -> ('f, 's) T2(M).t
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) T2(M).t
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) T2(M).t
val bind :
('a, 'e) T2(M).t ->
f:('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val map :
('a, 'e) T2(M).t ->
f:('a -> 'b) -> ('b, 'e) T2(M).t
val both :
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
end
val bind :
('a, 'e) T2(M).t ->
f:('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val return : 'a -> ('a, 'b) T2(M).t
val map :
('a, 'e) T2(M).t -> f:('a -> 'b) -> ('b, 'e) T2(M).t
val join :
(('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
val ignore_m :
('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
val all_ignore :
(Monoid.Unit.t, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
module Syntax :
sig
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
val ( >=> ) :
('a -> ('b, 'e) T2(M).t) ->
('b -> ('c, 'e) T2(M).t) -> 'a -> ('c, 'e) T2(M).t
val ( !! ) : 'a -> ('a, 'e) T2(M).t
val ( !$ ) :
('a -> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t ->
('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t -> ('e, 's) T2(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t ->
('e, 's) T2(M).t -> ('f, 's) T2(M).t
end
val pure : 'a -> ('a, 'e) T2(M).t
val accept : 'a -> ('a, 'e) T2(M).t
val reject : Monoid.Unit.t -> ('a, 'e) T2(M).t
val guard : bool -> (Monoid.Unit.t, 'e) T2(M).t
val on :
bool ->
(Monoid.Unit.t, 'e) T2(M).t ->
(Monoid.Unit.t, 'e) T2(M).t
val unless :
bool ->
(Monoid.Unit.t, 'e) T2(M).t ->
(Monoid.Unit.t, 'e) T2(M).t
val zero : Monoid.Unit.t -> ('a, 'e) T2(M).t
val plus :
('a, 'e) T2(M).t ->
('a, 'e) T2(M).t -> ('a, 'e) T2(M).t
end
end
module Writer :
sig
module type S =
sig
type state
type 'a t
type 'a m
type 'a e
val lift : 'a m -> 'a t
val run : 'a t -> 'a e
val write : Monads.Std.Monad.Writer.S.state -> unit t
val read : 'a t -> Monads.Std.Monad.Writer.S.state t
val listen :
'a t -> ('a * Monads.Std.Monad.Writer.S.state) t
val exec : unit t -> Monads.Std.Monad.Writer.S.state m
val void : 'a t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
val forever : 'a t -> 'b t
module Fn :
sig
val id : 'a -> 'a t
val ignore : 'a t -> Monoid.Unit.t t
val nothing : Monoid.Unit.t -> Monoid.Unit.t t
val non : ('a -> bool t) -> 'a -> bool t
val apply_n_times :
n:Monoid.Int.t -> ('a -> 'a t) -> 'a -> 'a t
val compose :
('b -> 'c t) -> ('a -> 'b t) -> 'a -> 'c t
end
module Pair :
sig
val fst : ('a * 'b) t -> 'a t
val snd : ('a * 'b) t -> 'b t
end
module Triple :
sig
val fst : ('a * 'b * 'c) t -> 'a t
val snd : ('a * 'b * 'c) t -> 'b t
val trd : ('a * 'b * 'c) t -> 'c t
end
module Lift :
sig
val nullary : 'a -> 'a t
val unary : ('a -> 'b) -> 'a t -> 'b t
val binary : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ternary :
('a -> 'b -> 'c -> 'd) ->
'a t -> 'b t -> 'c t -> 'd t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
f:(Monoid.Unit.t -> 'a t) ->
catch:(exn -> 'a t) -> 'a t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a t t -> 'a t t
val all_ignore : 'a t t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
val map : 'a t -> f:('a -> 'b t) -> 'b t t
val iter :
'a t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a t -> f:('a -> bool t) -> bool t
val for_all : 'a t -> f:('a -> bool t) -> bool t
val count :
'a t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> 'a t) -> 'a t
val find :
'a t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a t -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter : 'a t -> f:('a -> bool t) -> 'a t t
val filter_map :
'a t -> f:('a -> 'b Option.t t) -> 'b t t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a T.t -> f:('a -> bool t) -> bool t
val for_all :
'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a T.t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t -> f:('a -> 'b Option.t t) -> 'b T.t t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a T.t -> f:('a -> bool t) -> bool t
val for_all :
'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a T.t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t -> f:('a -> 'b Option.t t) -> 'b T.t t
end
end
module List :
sig
val all : 'a t List.t -> 'a List.t t
val all_ignore : 'a t List.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t List.t -> Monoid.Unit.t t
val map : 'a List.t -> f:('a -> 'b t) -> 'b List.t t
val iter :
'a List.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a List.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a List.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a List.t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a List.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a List.t -> f:('a -> bool t) -> bool t
val for_all : 'a List.t -> f:('a -> bool t) -> bool t
val count :
'a List.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b List.t -> f:('b -> 'a t) -> 'a t
val find :
'a List.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a List.t -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a List.t -> f:('a -> bool t) -> 'a List.t t
val filter_map :
'a List.t -> f:('a -> 'b Option.t t) -> 'b List.t t
end
module Seq :
sig
val all : 'a t Seq.t -> 'a Seq.t t
val all_ignore : 'a t Seq.t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t Seq.t -> Monoid.Unit.t t
val map : 'a Seq.t -> f:('a -> 'b t) -> 'b Seq.t t
val iter :
'a Seq.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a Seq.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a Seq.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a Seq.t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a Seq.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a Seq.t -> f:('a -> bool t) -> bool t
val for_all : 'a Seq.t -> f:('a -> bool t) -> bool t
val count :
'a Seq.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Seq.t -> f:('b -> 'a t) -> 'a t
val find :
'a Seq.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a Seq.t -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter : 'a Seq.t -> f:('a -> bool t) -> 'a Seq.t t
val filter_map :
'a Seq.t -> f:('a -> 'b Option.t t) -> 'b Seq.t t
end
val ( >=> ) : ('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Monad_infix :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
end
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val return : 'a -> 'a t
val map : 'a t -> f:('a -> 'b) -> 'b t
val join : 'a t t -> 'a t
val ignore_m : 'a t -> Monoid.Unit.t t
val all : 'a t list -> 'a list t
val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
module Let_syntax :
sig
val return : 'a -> 'a t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Let_syntax :
sig
val return : 'a -> 'a t
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val map : 'a t -> f:('a -> 'b) -> 'b t
val both : 'a t -> 'b t -> ('a * 'b) t
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
val ( >=> ) :
('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
end
type ('a, 'b) writer
module T1 :
functor (T : Monoid.S) (M : Monad) ->
sig
type state = T.t
type 'a m = 'a M.t
type 'a t =
('a, Monads.Std.Monad.Writer.T1.state)
Monads.Std.Monad.Writer.writer
Monads.Std.Monad.Writer.T1.m
type 'a e =
('a * Monads.Std.Monad.Writer.T1.state)
Monads.Std.Monad.Writer.T1.m
end
module Make :
functor (T : Monoid.S) (M : Monad) ->
sig
val lift : 'a M.t -> 'a T1(T)(M).t
val run : 'a T1(T)(M).t -> 'a T1(T)(M).e
val write : T.t -> Monoid.Unit.t T1(T)(M).t
val read : 'a T1(T)(M).t -> T.t T1(T)(M).t
val listen : 'a T1(T)(M).t -> ('a * T.t) T1(T)(M).t
val exec : Monoid.Unit.t T1(T)(M).t -> T.t M.t
val void : 'a T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t List.t ->
Monoid.Unit.t T1(T)(M).t
val forever : 'a T1(T)(M).t -> 'b T1(T)(M).t
module Fn :
sig
val id : 'a -> 'a T1(T)(M).t
val ignore :
'a T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
val nothing :
Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t
val non :
('a -> bool T1(T)(M).t) -> 'a -> bool T1(T)(M).t
val apply_n_times :
n:Monoid.Int.t ->
('a -> 'a T1(T)(M).t) -> 'a -> 'a T1(T)(M).t
val compose :
('b -> 'c T1(T)(M).t) ->
('a -> 'b T1(T)(M).t) -> 'a -> 'c T1(T)(M).t
end
module Pair :
sig
val fst : ('a * 'b) T1(T)(M).t -> 'a T1(T)(M).t
val snd : ('a * 'b) T1(T)(M).t -> 'b T1(T)(M).t
end
module Triple :
sig
val fst : ('a * 'b * 'c) T1(T)(M).t -> 'a T1(T)(M).t
val snd : ('a * 'b * 'c) T1(T)(M).t -> 'b T1(T)(M).t
val trd : ('a * 'b * 'c) T1(T)(M).t -> 'c T1(T)(M).t
end
module Lift :
sig
val nullary : 'a -> 'a T1(T)(M).t
val unary :
('a -> 'b) -> 'a T1(T)(M).t -> 'b T1(T)(M).t
val binary :
('a -> 'b -> 'c) ->
'a T1(T)(M).t -> 'b T1(T)(M).t -> 'c T1(T)(M).t
val ternary :
('a -> 'b -> 'c -> 'd) ->
'a T1(T)(M).t ->
'b T1(T)(M).t -> 'c T1(T)(M).t -> 'd T1(T)(M).t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t -> 'd T1(T)(M).t -> 'e T1(T)(M).t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t ->
'd T1(T)(M).t -> 'e T1(T)(M).t -> 'f T1(T)(M).t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t) ->
f:(Monoid.Unit.t -> 'a T1(T)(M).t) ->
catch:(exn -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a T1(T)(M).t t -> 'a t T1(T)(M).t
val all_ignore :
'a T1(T)(M).t t -> Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t t ->
Monoid.Unit.t T1(T)(M).t
val map :
'a t ->
f:('a -> 'b T1(T)(M).t) -> 'b t T1(T)(M).t
val iter :
'a t ->
f:('a -> Monoid.Unit.t T1(T)(M).t) ->
Monoid.Unit.t T1(T)(M).t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_right :
'a t ->
f:('a -> 'b -> 'b T1(T)(M).t) ->
init:'b -> 'b T1(T)(M).t
val reduce :
'a t ->
f:('a -> 'a -> 'a T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val exists :
'a t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val for_all :
'a t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val count :
'a t ->
f:('a -> bool T1(T)(M).t) ->
Monoid.Int.t T1(T)(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t ->
f:('b -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
val find :
'a t ->
f:('a -> bool T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val find_map :
'a t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Option.t T1(T)(M).t
val filter :
'a t ->
f:('a -> bool T1(T)(M).t) -> 'a t T1(T)(M).t
val filter_map :
'a t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b t T1(T)(M).t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all :
'a T1(T)(M).t T.t -> 'a T.t T1(T)(M).t
val all_ignore :
'a T1(T)(M).t T.t -> Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t T.t ->
Monoid.Unit.t T1(T)(M).t
val map :
'a T.t ->
f:('a -> 'b T1(T)(M).t) -> 'b T.t T1(T)(M).t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t T1(T)(M).t) ->
Monoid.Unit.t T1(T)(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) ->
'b T1(T)(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) ->
'b T1(T)(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b T1(T)(M).t) ->
init:'b -> 'b T1(T)(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> 'a T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val exists :
'a T.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val for_all :
'a T.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val count :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
Monoid.Int.t T1(T)(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
val find :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val find_map :
'a T.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Option.t T1(T)(M).t
val filter :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
'a T.t T1(T)(M).t
val filter_map :
'a T.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b T.t T1(T)(M).t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all :
'a T1(T)(M).t T.t -> 'a T.t T1(T)(M).t
val all_ignore :
'a T1(T)(M).t T.t -> Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t T.t ->
Monoid.Unit.t T1(T)(M).t
val map :
'a T.t ->
f:('a -> 'b T1(T)(M).t) -> 'b T.t T1(T)(M).t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t T1(T)(M).t) ->
Monoid.Unit.t T1(T)(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) ->
'b T1(T)(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) ->
'b T1(T)(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b T1(T)(M).t) ->
init:'b -> 'b T1(T)(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> 'a T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val exists :
'a T.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val for_all :
'a T.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val count :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
Monoid.Int.t T1(T)(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
val find :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val find_map :
'a T.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Option.t T1(T)(M).t
val filter :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
'a T.t T1(T)(M).t
val filter_map :
'a T.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b T.t T1(T)(M).t
end
end
module List :
sig
val all :
'a T1(T)(M).t List.t -> 'a List.t T1(T)(M).t
val all_ignore :
'a T1(T)(M).t List.t -> Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t List.t ->
Monoid.Unit.t T1(T)(M).t
val map :
'a List.t ->
f:('a -> 'b T1(T)(M).t) -> 'b List.t T1(T)(M).t
val iter :
'a List.t ->
f:('a -> Monoid.Unit.t T1(T)(M).t) ->
Monoid.Unit.t T1(T)(M).t
val fold :
'a List.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_left :
'a List.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_right :
'a List.t ->
f:('a -> 'b -> 'b T1(T)(M).t) ->
init:'b -> 'b T1(T)(M).t
val reduce :
'a List.t ->
f:('a -> 'a -> 'a T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val exists :
'a List.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val for_all :
'a List.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val count :
'a List.t ->
f:('a -> bool T1(T)(M).t) ->
Monoid.Int.t T1(T)(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b List.t ->
f:('b -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
val find :
'a List.t ->
f:('a -> bool T1(T)(M).t) -> 'a Option.t T1(T)(M).t
val find_map :
'a List.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Option.t T1(T)(M).t
val filter :
'a List.t ->
f:('a -> bool T1(T)(M).t) -> 'a List.t T1(T)(M).t
val filter_map :
'a List.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b List.t T1(T)(M).t
end
module Seq :
sig
val all : 'a T1(T)(M).t Seq.t -> 'a Seq.t T1(T)(M).t
val all_ignore :
'a T1(T)(M).t Seq.t -> Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t Seq.t ->
Monoid.Unit.t T1(T)(M).t
val map :
'a Seq.t ->
f:('a -> 'b T1(T)(M).t) -> 'b Seq.t T1(T)(M).t
val iter :
'a Seq.t ->
f:('a -> Monoid.Unit.t T1(T)(M).t) ->
Monoid.Unit.t T1(T)(M).t
val fold :
'a Seq.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_left :
'a Seq.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_right :
'a Seq.t ->
f:('a -> 'b -> 'b T1(T)(M).t) ->
init:'b -> 'b T1(T)(M).t
val reduce :
'a Seq.t ->
f:('a -> 'a -> 'a T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val exists :
'a Seq.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val for_all :
'a Seq.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val count :
'a Seq.t ->
f:('a -> bool T1(T)(M).t) ->
Monoid.Int.t T1(T)(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Seq.t ->
f:('b -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
val find :
'a Seq.t ->
f:('a -> bool T1(T)(M).t) -> 'a Option.t T1(T)(M).t
val find_map :
'a Seq.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Option.t T1(T)(M).t
val filter :
'a Seq.t ->
f:('a -> bool T1(T)(M).t) -> 'a Seq.t T1(T)(M).t
val filter_map :
'a Seq.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Seq.t T1(T)(M).t
end
val ( >=> ) :
('a -> 'b T1(T)(M).t) ->
('b -> 'c T1(T)(M).t) -> 'a -> 'c T1(T)(M).t
val ( !! ) : 'a -> 'a T1(T)(M).t
val ( !$ ) : ('a -> 'b) -> 'a T1(T)(M).t -> 'b T1(T)(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
'a T1(T)(M).t -> 'b T1(T)(M).t -> 'c T1(T)(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a T1(T)(M).t ->
'b T1(T)(M).t -> 'c T1(T)(M).t -> 'd T1(T)(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t -> 'd T1(T)(M).t -> 'e T1(T)(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t ->
'd T1(T)(M).t -> 'e T1(T)(M).t -> 'f T1(T)(M).t
val ( >>= ) :
'a T1(T)(M).t -> ('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val ( >>| ) :
'a T1(T)(M).t -> ('a -> 'b) -> 'b T1(T)(M).t
module Monad_infix :
sig
val ( >>= ) :
'a T1(T)(M).t ->
('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val ( >>| ) :
'a T1(T)(M).t -> ('a -> 'b) -> 'b T1(T)(M).t
end
val bind :
'a T1(T)(M).t ->
f:('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val return : 'a -> 'a T1(T)(M).t
val map : 'a T1(T)(M).t -> f:('a -> 'b) -> 'b T1(T)(M).t
val join : 'a T1(T)(M).t T1(T)(M).t -> 'a T1(T)(M).t
val ignore_m : 'a T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
val all : 'a T1(T)(M).t list -> 'a list T1(T)(M).t
val all_ignore :
Monoid.Unit.t T1(T)(M).t list ->
Monoid.Unit.t T1(T)(M).t
module Let_syntax :
sig
val return : 'a -> 'a T1(T)(M).t
val ( >>= ) :
'a T1(T)(M).t ->
('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val ( >>| ) :
'a T1(T)(M).t -> ('a -> 'b) -> 'b T1(T)(M).t
module Let_syntax :
sig
val return : 'a -> 'a T1(T)(M).t
val bind :
'a T1(T)(M).t ->
f:('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val map :
'a T1(T)(M).t -> f:('a -> 'b) -> 'b T1(T)(M).t
val both :
'a T1(T)(M).t ->
'b T1(T)(M).t -> ('a * 'b) T1(T)(M).t
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) :
'a T1(T)(M).t ->
('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val ( >>| ) :
'a T1(T)(M).t -> ('a -> 'b) -> 'b T1(T)(M).t
val ( >=> ) :
('a -> 'b T1(T)(M).t) ->
('b -> 'c T1(T)(M).t) -> 'a -> 'c T1(T)(M).t
val ( !! ) : 'a -> 'a T1(T)(M).t
val ( !$ ) :
('a -> 'b) -> 'a T1(T)(M).t -> 'b T1(T)(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
'a T1(T)(M).t -> 'b T1(T)(M).t -> 'c T1(T)(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a T1(T)(M).t ->
'b T1(T)(M).t -> 'c T1(T)(M).t -> 'd T1(T)(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t -> 'd T1(T)(M).t -> 'e T1(T)(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t ->
'd T1(T)(M).t -> 'e T1(T)(M).t -> 'f T1(T)(M).t
end
end
end
module Reader :
sig
module type S =
sig
type 'a t
type 'a m
type 'a e
val lift : 'a m -> 'a t
val run : 'a t -> 'a e
type env
val read : unit -> Monads.Std.Monad.Reader.S.env t
val void : 'a t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
val forever : 'a t -> 'b t
module Fn :
sig
val id : 'a -> 'a t
val ignore : 'a t -> Monoid.Unit.t t
val nothing : Monoid.Unit.t -> Monoid.Unit.t t
val non : ('a -> bool t) -> 'a -> bool t
val apply_n_times :
n:Monoid.Int.t -> ('a -> 'a t) -> 'a -> 'a t
val compose :
('b -> 'c t) -> ('a -> 'b t) -> 'a -> 'c t
end
module Pair :
sig
val fst : ('a * 'b) t -> 'a t
val snd : ('a * 'b) t -> 'b t
end
module Triple :
sig
val fst : ('a * 'b * 'c) t -> 'a t
val snd : ('a * 'b * 'c) t -> 'b t
val trd : ('a * 'b * 'c) t -> 'c t
end
module Lift :
sig
val nullary : 'a -> 'a t
val unary : ('a -> 'b) -> 'a t -> 'b t
val binary : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ternary :
('a -> 'b -> 'c -> 'd) ->
'a t -> 'b t -> 'c t -> 'd t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
f:(Monoid.Unit.t -> 'a t) ->
catch:(exn -> 'a t) -> 'a t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a t t -> 'a t t
val all_ignore : 'a t t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
val map : 'a t -> f:('a -> 'b t) -> 'b t t
val iter :
'a t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a t -> f:('a -> bool t) -> bool t
val for_all : 'a t -> f:('a -> bool t) -> bool t
val count :
'a t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> 'a t) -> 'a t
val find :
'a t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a t -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter : 'a t -> f:('a -> bool t) -> 'a t t
val filter_map :
'a t -> f:('a -> 'b Option.t t) -> 'b t t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a T.t -> f:('a -> bool t) -> bool t
val for_all :
'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a T.t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t -> f:('a -> 'b Option.t t) -> 'b T.t t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a T.t -> f:('a -> bool t) -> bool t
val for_all :
'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a T.t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t -> f:('a -> 'b Option.t t) -> 'b T.t t
end
end
module List :
sig
val all : 'a t List.t -> 'a List.t t
val all_ignore : 'a t List.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t List.t -> Monoid.Unit.t t
val map : 'a List.t -> f:('a -> 'b t) -> 'b List.t t
val iter :
'a List.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a List.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a List.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a List.t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a List.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a List.t -> f:('a -> bool t) -> bool t
val for_all : 'a List.t -> f:('a -> bool t) -> bool t
val count :
'a List.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b List.t -> f:('b -> 'a t) -> 'a t
val find :
'a List.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a List.t -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a List.t -> f:('a -> bool t) -> 'a List.t t
val filter_map :
'a List.t -> f:('a -> 'b Option.t t) -> 'b List.t t
end
module Seq :
sig
val all : 'a t Seq.t -> 'a Seq.t t
val all_ignore : 'a t Seq.t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t Seq.t -> Monoid.Unit.t t
val map : 'a Seq.t -> f:('a -> 'b t) -> 'b Seq.t t
val iter :
'a Seq.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a Seq.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a Seq.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a Seq.t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a Seq.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a Seq.t -> f:('a -> bool t) -> bool t
val for_all : 'a Seq.t -> f:('a -> bool t) -> bool t
val count :
'a Seq.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Seq.t -> f:('b -> 'a t) -> 'a t
val find :
'a Seq.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a Seq.t -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter : 'a Seq.t -> f:('a -> bool t) -> 'a Seq.t t
val filter_map :
'a Seq.t -> f:('a -> 'b Option.t t) -> 'b Seq.t t
end
val ( >=> ) : ('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Monad_infix :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
end
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val return : 'a -> 'a t
val map : 'a t -> f:('a -> 'b) -> 'b t
val join : 'a t t -> 'a t
val ignore_m : 'a t -> Monoid.Unit.t t
val all : 'a t list -> 'a list t
val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
module Let_syntax :
sig
val return : 'a -> 'a t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Let_syntax :
sig
val return : 'a -> 'a t
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val map : 'a t -> f:('a -> 'b) -> 'b t
val both : 'a t -> 'b t -> ('a * 'b) t
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
val ( >=> ) :
('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
end
module type S2 =
sig
type ('a, 'e) t
type 'a m
type ('a, 'e) e
val lift : 'a m -> ('a, 'e) t
val run : ('a, 'e) t -> ('a, 'e) e
val read : unit -> ('e, 'e) t
val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
val forever : ('a, 'e) t -> ('b, 'e) t
module Fn :
sig
val id : 'a -> ('a, 'e) t
val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
val non : ('a -> (bool, 'e) t) -> 'a -> (bool, 'e) t
val apply_n_times :
n:Monoid.Int.t ->
('a -> ('a, 'e) t) -> 'a -> ('a, 'e) t
val compose :
('b -> ('c, 'e) t) ->
('a -> ('b, 'e) t) -> 'a -> ('c, 'e) t
end
module Pair :
sig
val fst : ('a * 'b, 'e) t -> ('a, 'e) t
val snd : ('a * 'b, 'e) t -> ('b, 'e) t
end
module Triple :
sig
val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
end
module Lift :
sig
val nullary : 'a -> ('a, 'e) t
val unary : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val binary :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ternary :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
f:(Monoid.Unit.t -> ('a, 's) t) ->
catch:(exn -> ('a, 's) t) -> ('a, 's) t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : ('a, 'e) t t -> ('a t, 'e) t
val all_ignore :
('a, 'e) t t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
val map :
'a t -> f:('a -> ('b, 'e) t) -> ('b t, 'e) t
val iter :
'a t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a t -> f:('a -> (bool, 'e) t) -> ('a t, 'e) t
val filter_map :
'a t ->
f:('a -> ('b Option.t, 'e) t) -> ('b t, 'e) t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : ('a, 'e) t T.t -> ('a T.t, 'e) t
val all_ignore :
('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t T.t ->
(Monoid.Unit.t, 'e) t
val map :
'a T.t ->
f:('a -> ('b, 'e) t) -> ('b T.t, 'e) t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) t) ->
('a Option.t, 'e) t
val exists :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a T.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a T.t, 'e) t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b T.t, 'e) t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : ('a, 'e) t T.t -> ('a T.t, 'e) t
val all_ignore :
('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t T.t ->
(Monoid.Unit.t, 'e) t
val map :
'a T.t ->
f:('a -> ('b, 'e) t) -> ('b T.t, 'e) t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) t) ->
('a Option.t, 'e) t
val exists :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a T.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a T.t, 'e) t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b T.t, 'e) t
end
end
module List :
sig
val all : ('a, 'e) t List.t -> ('a List.t, 'e) t
val all_ignore :
('a, 'e) t List.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
val map :
'a List.t ->
f:('a -> ('b, 'e) t) -> ('b List.t, 'e) t
val iter :
'a List.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a List.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a List.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a List.t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a List.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a List.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a List.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a List.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b List.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a List.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a List.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b Option.t, 'e) t
val filter :
'a List.t ->
f:('a -> (bool, 'e) t) -> ('a List.t, 'e) t
val filter_map :
'a List.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b List.t, 'e) t
end
module Seq :
sig
val all : ('a, 'e) t Seq.t -> ('a Seq.t, 'e) t
val all_ignore :
('a, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
val map :
'a Seq.t -> f:('a -> ('b, 'e) t) -> ('b Seq.t, 'e) t
val iter :
'a Seq.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a Seq.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a Seq.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a Seq.t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a Seq.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a Seq.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a Seq.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a Seq.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Seq.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a Seq.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a Seq.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b Option.t, 'e) t
val filter :
'a Seq.t ->
f:('a -> (bool, 'e) t) -> ('a Seq.t, 'e) t
val filter_map :
'a Seq.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b Seq.t, 'e) t
end
val ( >=> ) :
('a -> ('b, 'e) t) ->
('b -> ('c, 'e) t) -> 'a -> ('c, 'e) t
val ( !! ) : 'a -> ('a, 'e) t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val bind :
('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val both :
('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
end
val bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val return : 'a -> ('a, 'b) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore :
(Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
module Syntax :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
val ( >=> ) :
('a -> ('b, 'e) t) ->
('b -> ('c, 'e) t) -> 'a -> ('c, 'e) t
val ( !! ) : 'a -> ('a, 'e) t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
end
end
type ('a, 'b) reader
type ('a, 'e) t = ('a, 'e) reader
type 'a m = 'a
type ('a, 'e) e = 'e -> 'a
val lift : 'a -> ('a, 'e) t
val run : ('a, 'e) t -> ('a, 'e) e
val read : Monoid.Unit.t -> ('e, 'e) t
val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
val forever : ('a, 'e) t -> ('b, 'e) t
module Fn :
sig
val id : 'a -> ('a, 'e) t
val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
val non : ('a -> (bool, 'e) t) -> 'a -> (bool, 'e) t
val apply_n_times :
n:Monoid.Int.t -> ('a -> ('a, 'e) t) -> 'a -> ('a, 'e) t
val compose :
('b -> ('c, 'e) t) ->
('a -> ('b, 'e) t) -> 'a -> ('c, 'e) t
end
module Pair :
sig
val fst : ('a * 'b, 'e) t -> ('a, 'e) t
val snd : ('a * 'b, 'e) t -> ('b, 'e) t
end
module Triple :
sig
val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
end
module Lift :
sig
val nullary : 'a -> ('a, 'e) t
val unary : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val binary :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ternary :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
f:(Monoid.Unit.t -> ('a, 's) t) ->
catch:(exn -> ('a, 's) t) -> ('a, 's) t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : ('a, 'e) reader t -> ('a t, 'e) reader
val all_ignore :
('a, 'e) reader t -> (Monoid.Unit.t, 'e) reader
val sequence :
(Monoid.Unit.t, 'e) reader t ->
(Monoid.Unit.t, 'e) reader
val map :
'a t ->
f:('a -> ('b, 'e) reader) -> ('b t, 'e) reader
val iter :
'a t ->
f:('a -> (Monoid.Unit.t, 'e) reader) ->
(Monoid.Unit.t, 'e) reader
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) reader) -> ('b, 'e) reader
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) reader) -> ('b, 'e) reader
val fold_right :
'a t ->
f:('a -> 'b -> ('b, 'e) reader) ->
init:'b -> ('b, 'e) reader
val reduce :
'a t ->
f:('a -> 'a -> ('a, 'e) reader) ->
('a Option.t, 'e) reader
val exists :
'a t ->
f:('a -> (bool, 'e) reader) -> (bool, 'e) reader
val for_all :
'a t ->
f:('a -> (bool, 'e) reader) -> (bool, 'e) reader
val count :
'a t ->
f:('a -> (bool, 'e) reader) ->
(Monoid.Int.t, 'e) reader
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> ('a, 'e) reader) -> ('a, 'e) reader
val find :
'a t ->
f:('a -> (bool, 'e) reader) ->
('a Option.t, 'e) reader
val find_map :
'a t ->
f:('a -> ('b Option.t, 'e) reader) ->
('b Option.t, 'e) reader
val filter :
'a t ->
f:('a -> (bool, 'e) reader) -> ('a t, 'e) reader
val filter_map :
'a t ->
f:('a -> ('b Option.t, 'e) reader) ->
('b t, 'e) reader
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : ('a, 'e) t T.t -> ('a T.t, 'e) t
val all_ignore :
('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val map :
'a T.t -> f:('a -> ('b, 'e) t) -> ('b T.t, 'e) t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a T.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a T.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a T.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a T.t -> f:('a -> (bool, 'e) t) -> ('a T.t, 'e) t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b T.t, 'e) t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : ('a, 'e) t T.t -> ('a T.t, 'e) t
val all_ignore :
('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val map :
'a T.t -> f:('a -> ('b, 'e) t) -> ('b T.t, 'e) t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a T.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a T.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a T.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a T.t -> f:('a -> (bool, 'e) t) -> ('a T.t, 'e) t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b T.t, 'e) t
end
end
module List :
sig
val all : ('a, 'e) t List.t -> ('a List.t, 'e) t
val all_ignore : ('a, 'e) t List.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
val map :
'a List.t -> f:('a -> ('b, 'e) t) -> ('b List.t, 'e) t
val iter :
'a List.t ->
f:('a -> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
val fold :
'a List.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a List.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a List.t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a List.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a List.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a List.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a List.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b List.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a List.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a List.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b Option.t, 'e) t
val filter :
'a List.t -> f:('a -> (bool, 'e) t) -> ('a List.t, 'e) t
val filter_map :
'a List.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b List.t, 'e) t
end
module Seq :
sig
val all : ('a, 'e) t Seq.t -> ('a Seq.t, 'e) t
val all_ignore : ('a, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
val map :
'a Seq.t -> f:('a -> ('b, 'e) t) -> ('b Seq.t, 'e) t
val iter :
'a Seq.t ->
f:('a -> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
val fold :
'a Seq.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a Seq.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a Seq.t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a Seq.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a Seq.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a Seq.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a Seq.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Seq.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a Seq.t -> f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a Seq.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b Option.t, 'e) t
val filter :
'a Seq.t -> f:('a -> (bool, 'e) t) -> ('a Seq.t, 'e) t
val filter_map :
'a Seq.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b Seq.t, 'e) t
end
val ( >=> ) :
('a -> ('b, 'e) t) -> ('b -> ('c, 'e) t) -> 'a -> ('c, 'e) t
val ( !! ) : 'a -> ('a, 'e) t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val ( !$$ ) :
('a -> 'b -> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
val ( >>= ) : ('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val bind :
('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
end
val bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val return : 'a -> ('a, 'b) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore :
(Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
module Syntax :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
val ( >=> ) :
('a -> ('b, 'e) t) ->
('b -> ('c, 'e) t) -> 'a -> ('c, 'e) t
val ( !! ) : 'a -> ('a, 'e) t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
end
module T1 :
functor (T : Core_kernel.Std.T) (M : Monad) ->
sig
type env = T.t
type 'a m = 'a M.t
type 'a t =
('a Monads.Std.Monad.Reader.T1.m,
Monads.Std.Monad.Reader.T1.env)
Monads.Std.Monad.Reader.reader
type 'a e =
Monads.Std.Monad.Reader.T1.env ->
'a Monads.Std.Monad.Reader.T1.m
end
module T2 :
functor (M : Monad) ->
sig
type 'a m = 'a M.t
type ('a, 'e) t =
('a Monads.Std.Monad.Reader.T2.m, 'e)
Monads.Std.Monad.Reader.reader
type ('a, 'e) e = 'e -> 'a Monads.Std.Monad.Reader.T2.m
end
module Make :
functor (T : Core_kernel.Std.T) (M : Monad) ->
sig
val lift : 'a M.t -> 'a T1(T)(M).t
val run : 'a T1(T)(M).t -> 'a T1(T)(M).e
val read : Monoid.Unit.t -> T.t T1(T)(M).t
val void : 'a T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t list ->
Monoid.Unit.t T1(T)(M).t
val forever : 'a T1(T)(M).t -> 'b T1(T)(M).t
module Fn :
sig
val id : 'a -> 'a T1(T)(M).t
val ignore :
'a T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
val nothing :
Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t
val non :
('a -> bool T1(T)(M).t) -> 'a -> bool T1(T)(M).t
val apply_n_times :
n:Monoid.Int.t ->
('a -> 'a T1(T)(M).t) -> 'a -> 'a T1(T)(M).t
val compose :
('b -> 'c T1(T)(M).t) ->
('a -> 'b T1(T)(M).t) -> 'a -> 'c T1(T)(M).t
end
module Pair :
sig
val fst : ('a * 'b) T1(T)(M).t -> 'a T1(T)(M).t
val snd : ('a * 'b) T1(T)(M).t -> 'b T1(T)(M).t
end
module Triple :
sig
val fst : ('a * 'b * 'c) T1(T)(M).t -> 'a T1(T)(M).t
val snd : ('a * 'b * 'c) T1(T)(M).t -> 'b T1(T)(M).t
val trd : ('a * 'b * 'c) T1(T)(M).t -> 'c T1(T)(M).t
end
module Lift :
sig
val nullary : 'a -> 'a T1(T)(M).t
val unary :
('a -> 'b) -> 'a T1(T)(M).t -> 'b T1(T)(M).t
val binary :
('a -> 'b -> 'c) ->
'a T1(T)(M).t -> 'b T1(T)(M).t -> 'c T1(T)(M).t
val ternary :
('a -> 'b -> 'c -> 'd) ->
'a T1(T)(M).t ->
'b T1(T)(M).t -> 'c T1(T)(M).t -> 'd T1(T)(M).t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t -> 'd T1(T)(M).t -> 'e T1(T)(M).t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t ->
'd T1(T)(M).t -> 'e T1(T)(M).t -> 'f T1(T)(M).t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t) ->
f:(Monoid.Unit.t -> 'a T1(T)(M).t) ->
catch:(exn -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a T1(T)(M).t t -> 'a t T1(T)(M).t
val all_ignore :
'a T1(T)(M).t t -> Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t t ->
Monoid.Unit.t T1(T)(M).t
val map :
'a t ->
f:('a -> 'b T1(T)(M).t) -> 'b t T1(T)(M).t
val iter :
'a t ->
f:('a -> Monoid.Unit.t T1(T)(M).t) ->
Monoid.Unit.t T1(T)(M).t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_right :
'a t ->
f:('a -> 'b -> 'b T1(T)(M).t) ->
init:'b -> 'b T1(T)(M).t
val reduce :
'a t ->
f:('a -> 'a -> 'a T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val exists :
'a t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val for_all :
'a t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val count :
'a t ->
f:('a -> bool T1(T)(M).t) ->
Monoid.Int.t T1(T)(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t ->
f:('b -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
val find :
'a t ->
f:('a -> bool T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val find_map :
'a t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Option.t T1(T)(M).t
val filter :
'a t ->
f:('a -> bool T1(T)(M).t) -> 'a t T1(T)(M).t
val filter_map :
'a t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b t T1(T)(M).t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all :
'a T1(T)(M).t T.t -> 'a T.t T1(T)(M).t
val all_ignore :
'a T1(T)(M).t T.t -> Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t T.t ->
Monoid.Unit.t T1(T)(M).t
val map :
'a T.t ->
f:('a -> 'b T1(T)(M).t) -> 'b T.t T1(T)(M).t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t T1(T)(M).t) ->
Monoid.Unit.t T1(T)(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) ->
'b T1(T)(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) ->
'b T1(T)(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b T1(T)(M).t) ->
init:'b -> 'b T1(T)(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> 'a T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val exists :
'a T.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val for_all :
'a T.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val count :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
Monoid.Int.t T1(T)(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
val find :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val find_map :
'a T.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Option.t T1(T)(M).t
val filter :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
'a T.t T1(T)(M).t
val filter_map :
'a T.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b T.t T1(T)(M).t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all :
'a T1(T)(M).t T.t -> 'a T.t T1(T)(M).t
val all_ignore :
'a T1(T)(M).t T.t -> Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t T.t ->
Monoid.Unit.t T1(T)(M).t
val map :
'a T.t ->
f:('a -> 'b T1(T)(M).t) -> 'b T.t T1(T)(M).t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t T1(T)(M).t) ->
Monoid.Unit.t T1(T)(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) ->
'b T1(T)(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) ->
'b T1(T)(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b T1(T)(M).t) ->
init:'b -> 'b T1(T)(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> 'a T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val exists :
'a T.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val for_all :
'a T.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val count :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
Monoid.Int.t T1(T)(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
val find :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val find_map :
'a T.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Option.t T1(T)(M).t
val filter :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
'a T.t T1(T)(M).t
val filter_map :
'a T.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b T.t T1(T)(M).t
end
end
module List :
sig
val all : 'a T1(T)(M).t list -> 'a list T1(T)(M).t
val all_ignore :
'a T1(T)(M).t list -> Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t list ->
Monoid.Unit.t T1(T)(M).t
val map :
'a list ->
f:('a -> 'b T1(T)(M).t) -> 'b list T1(T)(M).t
val iter :
'a list ->
f:('a -> Monoid.Unit.t T1(T)(M).t) ->
Monoid.Unit.t T1(T)(M).t
val fold :
'a list ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_left :
'a list ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_right :
'a list ->
f:('a -> 'b -> 'b T1(T)(M).t) ->
init:'b -> 'b T1(T)(M).t
val reduce :
'a list ->
f:('a -> 'a -> 'a T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val exists :
'a list ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val for_all :
'a list ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val count :
'a list ->
f:('a -> bool T1(T)(M).t) ->
Monoid.Int.t T1(T)(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list -> f:('b -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
val find :
'a list ->
f:('a -> bool T1(T)(M).t) -> 'a Option.t T1(T)(M).t
val find_map :
'a list ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Option.t T1(T)(M).t
val filter :
'a list ->
f:('a -> bool T1(T)(M).t) -> 'a list T1(T)(M).t
val filter_map :
'a list ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b list T1(T)(M).t
end
module Seq :
sig
val all :
'a T1(T)(M).t Core_kernel.Std.Sequence.t ->
'a Core_kernel.Std.Sequence.t T1(T)(M).t
val all_ignore :
'a T1(T)(M).t Core_kernel.Std.Sequence.t ->
Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t Core_kernel.Std.Sequence.t ->
Monoid.Unit.t T1(T)(M).t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b T1(T)(M).t) ->
'b Core_kernel.Std.Sequence.t T1(T)(M).t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> Monoid.Unit.t T1(T)(M).t) ->
Monoid.Unit.t T1(T)(M).t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> 'b T1(T)(M).t) ->
init:'b -> 'b T1(T)(M).t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> 'a T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(T)(M).t) ->
Monoid.Int.t T1(T)(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(T)(M).t) -> 'a Option.t T1(T)(M).t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Option.t T1(T)(M).t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(T)(M).t) ->
'a Core_kernel.Std.Sequence.t T1(T)(M).t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Core_kernel.Std.Sequence.t T1(T)(M).t
end
val ( >=> ) :
('a -> 'b T1(T)(M).t) ->
('b -> 'c T1(T)(M).t) -> 'a -> 'c T1(T)(M).t
val ( !! ) : 'a -> 'a T1(T)(M).t
val ( !$ ) : ('a -> 'b) -> 'a T1(T)(M).t -> 'b T1(T)(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
'a T1(T)(M).t -> 'b T1(T)(M).t -> 'c T1(T)(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a T1(T)(M).t ->
'b T1(T)(M).t -> 'c T1(T)(M).t -> 'd T1(T)(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t -> 'd T1(T)(M).t -> 'e T1(T)(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t ->
'd T1(T)(M).t -> 'e T1(T)(M).t -> 'f T1(T)(M).t
val ( >>= ) :
'a T1(T)(M).t -> ('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val ( >>| ) :
'a T1(T)(M).t -> ('a -> 'b) -> 'b T1(T)(M).t
module Monad_infix :
sig
val ( >>= ) :
'a T1(T)(M).t ->
('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val ( >>| ) :
'a T1(T)(M).t -> ('a -> 'b) -> 'b T1(T)(M).t
end
val bind :
'a T1(T)(M).t ->
f:('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val return : 'a -> 'a T1(T)(M).t
val map : 'a T1(T)(M).t -> f:('a -> 'b) -> 'b T1(T)(M).t
val join : 'a T1(T)(M).t T1(T)(M).t -> 'a T1(T)(M).t
val ignore_m : 'a T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
val all : 'a T1(T)(M).t list -> 'a list T1(T)(M).t
val all_ignore :
Monoid.Unit.t T1(T)(M).t list ->
Monoid.Unit.t T1(T)(M).t
module Let_syntax :
sig
val return : 'a -> 'a T1(T)(M).t
val ( >>= ) :
'a T1(T)(M).t ->
('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val ( >>| ) :
'a T1(T)(M).t -> ('a -> 'b) -> 'b T1(T)(M).t
module Let_syntax :
sig
val return : 'a -> 'a T1(T)(M).t
val bind :
'a T1(T)(M).t ->
f:('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val map :
'a T1(T)(M).t -> f:('a -> 'b) -> 'b T1(T)(M).t
val both :
'a T1(T)(M).t ->
'b T1(T)(M).t -> ('a * 'b) T1(T)(M).t
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) :
'a T1(T)(M).t ->
('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val ( >>| ) :
'a T1(T)(M).t -> ('a -> 'b) -> 'b T1(T)(M).t
val ( >=> ) :
('a -> 'b T1(T)(M).t) ->
('b -> 'c T1(T)(M).t) -> 'a -> 'c T1(T)(M).t
val ( !! ) : 'a -> 'a T1(T)(M).t
val ( !$ ) :
('a -> 'b) -> 'a T1(T)(M).t -> 'b T1(T)(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
'a T1(T)(M).t -> 'b T1(T)(M).t -> 'c T1(T)(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a T1(T)(M).t ->
'b T1(T)(M).t -> 'c T1(T)(M).t -> 'd T1(T)(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t -> 'd T1(T)(M).t -> 'e T1(T)(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t ->
'd T1(T)(M).t -> 'e T1(T)(M).t -> 'f T1(T)(M).t
end
end
module Make2 :
functor (M : Monad) ->
sig
val lift : 'a M.t -> ('a, 'e) T2(M).t
val run : ('a, 'e) T2(M).t -> ('a, 'e) T2(M).e
val read : Monoid.Unit.t -> ('e, 'e) T2(M).t
val void :
('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
module Fn :
sig
val id : 'a -> ('a, 'e) T2(M).t
val ignore :
('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
val nothing :
Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
val non :
('a -> (bool, 'e) T2(M).t) ->
'a -> (bool, 'e) T2(M).t
val apply_n_times :
n:Monoid.Int.t ->
('a -> ('a, 'e) T2(M).t) -> 'a -> ('a, 'e) T2(M).t
val compose :
('b -> ('c, 'e) T2(M).t) ->
('a -> ('b, 'e) T2(M).t) -> 'a -> ('c, 'e) T2(M).t
end
module Pair :
sig
val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
end
module Triple :
sig
val fst :
('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
val snd :
('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
val trd :
('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
end
module Lift :
sig
val nullary : 'a -> ('a, 'e) T2(M).t
val unary :
('a -> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
val binary :
('a -> 'b -> 'c) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
val ternary :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t ->
('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t -> ('e, 's) T2(M).t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t ->
('e, 's) T2(M).t -> ('f, 's) T2(M).t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t ->
(Monoid.Unit.t, 's) T2(M).t) ->
f:(Monoid.Unit.t -> ('a, 's) T2(M).t) ->
catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
end
module Collection :
sig
module type S =
sig
type 'a t
val all :
('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b t, 'e) T2(M).t
val iter :
'a t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val for_all :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val count :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t ->
f:('b -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
val find :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a t, 'e) T2(M).t
val filter_map :
'a t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b t, 'e) T2(M).t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all :
('a, 'e) T2(M).t T.t -> ('a T.t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a T.t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val count :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> ('a, 'e) T2(M).t) ->
('a, 'e) T2(M).t
val find :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a T.t, 'e) T2(M).t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all :
('a, 'e) T2(M).t T.t -> ('a T.t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a T.t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val count :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> ('a, 'e) T2(M).t) ->
('a, 'e) T2(M).t
val find :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a T.t, 'e) T2(M).t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
end
end
module List :
sig
val all :
('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a list ->
f:('a -> ('b, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
val iter :
'a list ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a list ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a list ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a list ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a list ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a list ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val for_all :
'a list ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val count :
'a list ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list ->
f:('b -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
val find :
'a list ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a list ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a list ->
f:('a -> (bool, 'e) T2(M).t) ->
('a list, 'e) T2(M).t
val filter_map :
'a list ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b list, 'e) T2(M).t
end
module Seq :
sig
val all :
('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
('a Core_kernel.Std.Sequence.t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t
Core_kernel.Std.Sequence.t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b Core_kernel.Std.Sequence.t, 'e) T2(M).t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Core_kernel.Std.Sequence.t, 'e) T2(M).t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Core_kernel.Std.Sequence.t, 'e) T2(M).t
end
val ( >=> ) :
('a -> ('b, 'e) T2(M).t) ->
('b -> ('c, 'e) T2(M).t) -> 'a -> ('c, 'e) T2(M).t
val ( !! ) : 'a -> ('a, 'e) T2(M).t
val ( !$ ) :
('a -> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t ->
('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t -> ('e, 's) T2(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t ->
('e, 's) T2(M).t -> ('f, 's) T2(M).t
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) T2(M).t
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) T2(M).t
val bind :
('a, 'e) T2(M).t ->
f:('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val map :
('a, 'e) T2(M).t ->
f:('a -> 'b) -> ('b, 'e) T2(M).t
val both :
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
end
val bind :
('a, 'e) T2(M).t ->
f:('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val return : 'a -> ('a, 'b) T2(M).t
val map :
('a, 'e) T2(M).t -> f:('a -> 'b) -> ('b, 'e) T2(M).t
val join :
(('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
val ignore_m :
('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
val all_ignore :
(Monoid.Unit.t, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
module Syntax :
sig
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
val ( >=> ) :
('a -> ('b, 'e) T2(M).t) ->
('b -> ('c, 'e) T2(M).t) -> 'a -> ('c, 'e) T2(M).t
val ( !! ) : 'a -> ('a, 'e) T2(M).t
val ( !$ ) :
('a -> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t ->
('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t -> ('e, 's) T2(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t ->
('e, 's) T2(M).t -> ('f, 's) T2(M).t
end
end
end
module State :
sig
type ('a, 'e) storage
type ('a, 'e) state
module type S =
sig
type 'a t
type 'a m
type 'a e
val lift : 'a m -> 'a t
val run : 'a t -> 'a e
val void : 'a t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
val forever : 'a t -> 'b t
module Fn :
sig
val id : 'a -> 'a t
val ignore : 'a t -> Monoid.Unit.t t
val nothing : Monoid.Unit.t -> Monoid.Unit.t t
val non : ('a -> bool t) -> 'a -> bool t
val apply_n_times :
n:Monoid.Int.t -> ('a -> 'a t) -> 'a -> 'a t
val compose :
('b -> 'c t) -> ('a -> 'b t) -> 'a -> 'c t
end
module Pair :
sig
val fst : ('a * 'b) t -> 'a t
val snd : ('a * 'b) t -> 'b t
end
module Triple :
sig
val fst : ('a * 'b * 'c) t -> 'a t
val snd : ('a * 'b * 'c) t -> 'b t
val trd : ('a * 'b * 'c) t -> 'c t
end
module Lift :
sig
val nullary : 'a -> 'a t
val unary : ('a -> 'b) -> 'a t -> 'b t
val binary : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ternary :
('a -> 'b -> 'c -> 'd) ->
'a t -> 'b t -> 'c t -> 'd t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
f:(Monoid.Unit.t -> 'a t) ->
catch:(exn -> 'a t) -> 'a t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a t t -> 'a t t
val all_ignore : 'a t t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
val map : 'a t -> f:('a -> 'b t) -> 'b t t
val iter :
'a t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a t -> f:('a -> bool t) -> bool t
val for_all : 'a t -> f:('a -> bool t) -> bool t
val count :
'a t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> 'a t) -> 'a t
val find :
'a t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a t -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter : 'a t -> f:('a -> bool t) -> 'a t t
val filter_map :
'a t -> f:('a -> 'b Option.t t) -> 'b t t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a T.t -> f:('a -> bool t) -> bool t
val for_all :
'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a T.t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t -> f:('a -> 'b Option.t t) -> 'b T.t t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a T.t -> f:('a -> bool t) -> bool t
val for_all :
'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a T.t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t -> f:('a -> 'b Option.t t) -> 'b T.t t
end
end
module List :
sig
val all : 'a t List.t -> 'a List.t t
val all_ignore : 'a t List.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t List.t -> Monoid.Unit.t t
val map : 'a List.t -> f:('a -> 'b t) -> 'b List.t t
val iter :
'a List.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a List.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a List.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a List.t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a List.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a List.t -> f:('a -> bool t) -> bool t
val for_all : 'a List.t -> f:('a -> bool t) -> bool t
val count :
'a List.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b List.t -> f:('b -> 'a t) -> 'a t
val find :
'a List.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a List.t -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a List.t -> f:('a -> bool t) -> 'a List.t t
val filter_map :
'a List.t -> f:('a -> 'b Option.t t) -> 'b List.t t
end
module Seq :
sig
val all : 'a t Seq.t -> 'a Seq.t t
val all_ignore : 'a t Seq.t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t Seq.t -> Monoid.Unit.t t
val map : 'a Seq.t -> f:('a -> 'b t) -> 'b Seq.t t
val iter :
'a Seq.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a Seq.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a Seq.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a Seq.t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a Seq.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a Seq.t -> f:('a -> bool t) -> bool t
val for_all : 'a Seq.t -> f:('a -> bool t) -> bool t
val count :
'a Seq.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Seq.t -> f:('b -> 'a t) -> 'a t
val find :
'a Seq.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a Seq.t -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter : 'a Seq.t -> f:('a -> bool t) -> 'a Seq.t t
val filter_map :
'a Seq.t -> f:('a -> 'b Option.t t) -> 'b Seq.t t
end
val ( >=> ) : ('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Monad_infix :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
end
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val return : 'a -> 'a t
val map : 'a t -> f:('a -> 'b) -> 'b t
val join : 'a t t -> 'a t
val ignore_m : 'a t -> Monoid.Unit.t t
val all : 'a t list -> 'a list t
val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
module Let_syntax :
sig
val return : 'a -> 'a t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Let_syntax :
sig
val return : 'a -> 'a t
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val map : 'a t -> f:('a -> 'b) -> 'b t
val both : 'a t -> 'b t -> ('a * 'b) t
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
val ( >=> ) :
('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
type env
val put : Monads.Std.Monad.State.S.env -> unit t
val get : unit -> Monads.Std.Monad.State.S.env t
val gets : (Monads.Std.Monad.State.S.env -> 'r) -> 'r t
val update :
(Monads.Std.Monad.State.S.env ->
Monads.Std.Monad.State.S.env) ->
unit t
end
module type S2 =
sig
type ('a, 'e) t
type 'a m
type ('a, 'e) e
val lift : 'a m -> ('a, 'e) t
val run : ('a, 'e) t -> ('a, 'e) e
val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
val forever : ('a, 'e) t -> ('b, 'e) t
module Fn :
sig
val id : 'a -> ('a, 'e) t
val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
val non : ('a -> (bool, 'e) t) -> 'a -> (bool, 'e) t
val apply_n_times :
n:Monoid.Int.t ->
('a -> ('a, 'e) t) -> 'a -> ('a, 'e) t
val compose :
('b -> ('c, 'e) t) ->
('a -> ('b, 'e) t) -> 'a -> ('c, 'e) t
end
module Pair :
sig
val fst : ('a * 'b, 'e) t -> ('a, 'e) t
val snd : ('a * 'b, 'e) t -> ('b, 'e) t
end
module Triple :
sig
val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
end
module Lift :
sig
val nullary : 'a -> ('a, 'e) t
val unary : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val binary :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ternary :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
f:(Monoid.Unit.t -> ('a, 's) t) ->
catch:(exn -> ('a, 's) t) -> ('a, 's) t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : ('a, 'e) t t -> ('a t, 'e) t
val all_ignore :
('a, 'e) t t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
val map :
'a t -> f:('a -> ('b, 'e) t) -> ('b t, 'e) t
val iter :
'a t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a t -> f:('a -> (bool, 'e) t) -> ('a t, 'e) t
val filter_map :
'a t ->
f:('a -> ('b Option.t, 'e) t) -> ('b t, 'e) t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : ('a, 'e) t T.t -> ('a T.t, 'e) t
val all_ignore :
('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t T.t ->
(Monoid.Unit.t, 'e) t
val map :
'a T.t ->
f:('a -> ('b, 'e) t) -> ('b T.t, 'e) t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) t) ->
('a Option.t, 'e) t
val exists :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a T.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a T.t, 'e) t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b T.t, 'e) t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : ('a, 'e) t T.t -> ('a T.t, 'e) t
val all_ignore :
('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t T.t ->
(Monoid.Unit.t, 'e) t
val map :
'a T.t ->
f:('a -> ('b, 'e) t) -> ('b T.t, 'e) t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) t) ->
('a Option.t, 'e) t
val exists :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a T.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a T.t, 'e) t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b T.t, 'e) t
end
end
module List :
sig
val all : ('a, 'e) t List.t -> ('a List.t, 'e) t
val all_ignore :
('a, 'e) t List.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
val map :
'a List.t ->
f:('a -> ('b, 'e) t) -> ('b List.t, 'e) t
val iter :
'a List.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a List.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a List.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a List.t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a List.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a List.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a List.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a List.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b List.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a List.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a List.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b Option.t, 'e) t
val filter :
'a List.t ->
f:('a -> (bool, 'e) t) -> ('a List.t, 'e) t
val filter_map :
'a List.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b List.t, 'e) t
end
module Seq :
sig
val all : ('a, 'e) t Seq.t -> ('a Seq.t, 'e) t
val all_ignore :
('a, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
val map :
'a Seq.t -> f:('a -> ('b, 'e) t) -> ('b Seq.t, 'e) t
val iter :
'a Seq.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a Seq.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a Seq.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a Seq.t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a Seq.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a Seq.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a Seq.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a Seq.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Seq.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a Seq.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a Seq.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b Option.t, 'e) t
val filter :
'a Seq.t ->
f:('a -> (bool, 'e) t) -> ('a Seq.t, 'e) t
val filter_map :
'a Seq.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b Seq.t, 'e) t
end
val ( >=> ) :
('a -> ('b, 'e) t) ->
('b -> ('c, 'e) t) -> 'a -> ('c, 'e) t
val ( !! ) : 'a -> ('a, 'e) t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val bind :
('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val both :
('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
end
val bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val return : 'a -> ('a, 'b) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore :
(Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
module Syntax :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
val ( >=> ) :
('a -> ('b, 'e) t) ->
('b -> ('c, 'e) t) -> 'a -> ('c, 'e) t
val ( !! ) : 'a -> ('a, 'e) t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
end
val put : 's -> (unit, 's) t
val get : unit -> ('s, 's) t
val gets : ('s -> 'r) -> ('r, 's) t
val update : ('s -> 's) -> (unit, 's) t
end
module Multi :
sig
type status = [ `Current | `Dead | `Live ]
type 'a contexts
type id
module Id :
sig
type t = id
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val of_string : Monoid.String.t -> t
val to_string : t -> Monoid.String.t
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> Monoid.Int.t
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> Monoid.Int.t
val descending : t -> t -> Monoid.Int.t
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> Monoid.Int.t
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = id
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(id, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : id -> 'a -> 'a t
val of_alist :
(id * 'a) List.t ->
[ `Duplicate_key of id | `Ok of 'a t ]
val of_alist_or_error :
(id * 'a) List.t -> 'a t Base__.Or_error.t
val of_alist_exn : (id * 'a) List.t -> 'a t
val of_alist_multi :
(id * 'a) List.t -> 'a List.t t
val of_alist_fold :
(id * 'a) List.t ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(id * 'a) List.t ->
f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(id * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(id * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:Monoid.Int.t ->
f:(Monoid.Int.t -> id * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:id -> data:'v -> Monoid.Unit.t) ->
Monoid.Unit.t) ->
[ `Duplicate_key of id | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(id, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
id Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> Monoid.Int.t
val add : 'a t -> key:id -> data:'a -> 'a t
val add_multi :
'a List.t t ->
key:id -> data:'a -> 'a List.t t
val remove_multi :
'a List.t t -> id -> 'a List.t t
val change :
'a t ->
id -> f:('a Option.t -> 'a Option.t) -> 'a t
val update :
'a t -> id -> f:('a Option.t -> 'a) -> 'a t
val find : 'a t -> id -> 'a Option.t
val find_exn : 'a t -> id -> 'a
val remove : 'a t -> id -> 'a t
val mem : 'a t -> id -> bool
val iter_keys :
'a t ->
f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
val iter :
'a t ->
f:('a -> Monoid.Unit.t) -> Monoid.Unit.t
val iteri :
'a t ->
f:(key:id -> data:'a -> Monoid.Unit.t) ->
Monoid.Unit.t
val iter2 :
'a t ->
'b t ->
f:(key:id ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
Monoid.Unit.t) ->
Monoid.Unit.t
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:id -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:id -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:id -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:id ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys :
'a t -> f:(id -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:id -> data:'a -> bool) -> 'a t
val filter_map :
'a t -> f:('a -> 'b Option.t) -> 'b t
val filter_mapi :
'a t ->
f:(key:id -> data:'a -> 'b Option.t) -> 'b t
val partition_mapi :
'a t ->
f:(key:id ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:id -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> Monoid.Int.t) ->
'a t -> 'a t -> Monoid.Int.t
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> id List.t
val data : 'a t -> 'a List.t
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (id * 'a) List.t
val validate :
name:(id -> Monoid.String.t) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:id ->
[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] -> 'c Option.t) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(id, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (id * 'a) Option.t
val min_elt_exn : 'a t -> id * 'a
val max_elt : 'a t -> (id * 'a) Option.t
val max_elt_exn : 'a t -> id * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:id -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:id -> data:'a -> bool) -> bool
val count :
'a t -> f:('a -> bool) -> Monoid.Int.t
val counti :
'a t ->
f:(key:id -> data:'a -> bool) -> Monoid.Int.t
val split :
'a t ->
id -> 'a t * (id * 'a) Option.t * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:id Base__.Maybe_bound.t ->
upper_bound:id Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:id ->
max:id ->
init:'b ->
f:(key:id -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:id -> max:id -> (id * 'a) List.t
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> id -> (id * 'a) Option.t
val nth :
'a t -> Monoid.Int.t -> (id * 'a) Option.t
val nth_exn : 'a t -> Monoid.Int.t -> id * 'a
val rank : 'a t -> id -> Monoid.Int.t Option.t
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:id ->
?keys_less_or_equal_to:id ->
'a t -> (id * 'a) Base__.Sequence.t
val obs :
id Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
id Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp : Sexplib.Sexp.t -> id
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(id, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : id -> 'a -> 'a t
val of_alist :
(id * 'a) List.t ->
[ `Duplicate_key of id | `Ok of 'a t ]
val of_alist_or_error :
(id * 'a) List.t -> 'a t Base__.Or_error.t
val of_alist_exn : (id * 'a) List.t -> 'a t
val of_alist_multi :
(id * 'a) List.t -> 'a List.t t
val of_alist_fold :
(id * 'a) List.t ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(id * 'a) List.t -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(id * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(id * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:Monoid.Int.t ->
f:(Monoid.Int.t -> id * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:id -> data:'v -> Monoid.Unit.t) ->
Monoid.Unit.t) ->
[ `Duplicate_key of id | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(id, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
id Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> Monoid.Int.t
val add : 'a t -> key:id -> data:'a -> 'a t
val add_multi :
'a List.t t -> key:id -> data:'a -> 'a List.t t
val remove_multi : 'a List.t t -> id -> 'a List.t t
val change :
'a t ->
id -> f:('a Option.t -> 'a Option.t) -> 'a t
val update :
'a t -> id -> f:('a Option.t -> 'a) -> 'a t
val find : 'a t -> id -> 'a Option.t
val find_exn : 'a t -> id -> 'a
val remove : 'a t -> id -> 'a t
val mem : 'a t -> id -> bool
val iter_keys :
'a t -> f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
val iter :
'a t -> f:('a -> Monoid.Unit.t) -> Monoid.Unit.t
val iteri :
'a t ->
f:(key:id -> data:'a -> Monoid.Unit.t) ->
Monoid.Unit.t
val iter2 :
'a t ->
'b t ->
f:(key:id ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
Monoid.Unit.t) ->
Monoid.Unit.t
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:id -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:id -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:id -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:id ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(id -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:id -> data:'a -> bool) -> 'a t
val filter_map :
'a t -> f:('a -> 'b Option.t) -> 'b t
val filter_mapi :
'a t ->
f:(key:id -> data:'a -> 'b Option.t) -> 'b t
val partition_mapi :
'a t ->
f:(key:id ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:id -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> Monoid.Int.t) ->
'a t -> 'a t -> Monoid.Int.t
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> id List.t
val data : 'a t -> 'a List.t
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (id * 'a) List.t
val validate :
name:(id -> Monoid.String.t) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:id ->
[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] -> 'c Option.t) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(id, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (id * 'a) Option.t
val min_elt_exn : 'a t -> id * 'a
val max_elt : 'a t -> (id * 'a) Option.t
val max_elt_exn : 'a t -> id * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:id -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:id -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> Monoid.Int.t
val counti :
'a t ->
f:(key:id -> data:'a -> bool) -> Monoid.Int.t
val split :
'a t -> id -> 'a t * (id * 'a) Option.t * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:id Base__.Maybe_bound.t ->
upper_bound:id Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:id ->
max:id ->
init:'b ->
f:(key:id -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:id -> max:id -> (id * 'a) List.t
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> id -> (id * 'a) Option.t
val nth :
'a t -> Monoid.Int.t -> (id * 'a) Option.t
val nth_exn : 'a t -> Monoid.Int.t -> id * 'a
val rank : 'a t -> id -> Monoid.Int.t Option.t
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:id ->
?keys_less_or_equal_to:id ->
'a t -> (id * 'a) Base__.Sequence.t
val obs :
id Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
id Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> id
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : id Bin_prot.Type_class.t
val bin_read_t :
id Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> id)
Bin_prot.Read.reader
val bin_reader_t :
id Bin_prot.Type_class.reader
val bin_size_t :
id Bin_prot.Size.sizer
val bin_write_t :
id Bin_prot.Write.writer
val bin_writer_t :
id Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t :
('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t :
('a, 'a t) Bin_prot.Write.writer1
val bin_read_t :
('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, Monoid.Int.t -> 'a t)
Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t :
('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
id -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, Monoid.Int.t -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = id
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness =
Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(id, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare :
t -> t -> Core_kernel__.Import.int
val length : t -> Monoid.Int.t
val is_empty : t -> bool
val iter :
t -> f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
val fold :
t ->
init:'accum ->
f:('accum -> id -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum ->
id -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(id -> bool) -> bool
val for_all : t -> f:(id -> bool) -> bool
val count : t -> f:(id -> bool) -> Monoid.Int.t
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(id -> 'sum) -> 'sum
val find : t -> f:(id -> bool) -> id Option.t
val find_map :
t -> f:(id -> 'a Option.t) -> 'a Option.t
val to_list : t -> id List.t
val to_array : t -> id array
val invariants : t -> bool
val mem : t -> id -> bool
val add : t -> id -> t
val remove : t -> id -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(id, id) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> Monoid.Int.t
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
id ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(id -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of id * id
| `Left of id
| `Right of id ] -> Monoid.Unit.t) ->
Monoid.Unit.t
val filter : t -> f:(id -> bool) -> t
val partition_tf : t -> f:(id -> bool) -> t * t
val elements : t -> id List.t
val min_elt : t -> id Option.t
val min_elt_exn : t -> id
val max_elt : t -> id Option.t
val max_elt_exn : t -> id
val choose : t -> id Option.t
val choose_exn : t -> id
val split : t -> id -> t * id Option.t * t
val group_by :
t -> equiv:(id -> id -> bool) -> t List.t
val find_exn : t -> f:(id -> bool) -> id
val find_index :
t -> Monoid.Int.t -> id Option.t
val nth : t -> Monoid.Int.t -> id Option.t
val remove_index : t -> Monoid.Int.t -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:id ->
?less_or_equal_to:id ->
t -> id Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:id ->
?less_or_equal_to:id ->
t ->
t ->
(id, id)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(id -> 'data) ->
(id, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
id Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
id Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : id -> t
val union_list : t List.t -> t
val of_list : id List.t -> t
val of_array : id array -> t
val of_sorted_array :
id array -> t Base__.Or_error.t
val of_sorted_array_unchecked : id array -> t
val of_increasing_iterator_unchecked :
len:Monoid.Int.t ->
f:(Monoid.Int.t -> id) -> t
val stable_dedup_list : id List.t -> id List.t
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> id) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> id Option.t) -> t
val of_tree : t -> t
val of_hash_set :
id Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(id, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(id, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t ->
t
val gen :
id Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp :
Sexplib.Sexp.t -> id
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (id, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> Monoid.Int.t
val is_empty : t -> bool
val iter :
t -> f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
val fold :
t ->
init:'accum ->
f:('accum -> id -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> id -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(id -> bool) -> bool
val for_all : t -> f:(id -> bool) -> bool
val count : t -> f:(id -> bool) -> Monoid.Int.t
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(id -> 'sum) -> 'sum
val find : t -> f:(id -> bool) -> id Option.t
val find_map :
t -> f:(id -> 'a Option.t) -> 'a Option.t
val to_list : t -> id List.t
val to_array : t -> id array
val invariants : t -> bool
val mem : t -> id -> bool
val add : t -> id -> t
val remove : t -> id -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (id, id) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> Monoid.Int.t
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
id ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(id -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of id * id
| `Left of id
| `Right of id ] -> Monoid.Unit.t) ->
Monoid.Unit.t
val filter : t -> f:(id -> bool) -> t
val partition_tf : t -> f:(id -> bool) -> t * t
val elements : t -> id List.t
val min_elt : t -> id Option.t
val min_elt_exn : t -> id
val max_elt : t -> id Option.t
val max_elt_exn : t -> id
val choose : t -> id Option.t
val choose_exn : t -> id
val split : t -> id -> t * id Option.t * t
val group_by :
t -> equiv:(id -> id -> bool) -> t List.t
val find_exn : t -> f:(id -> bool) -> id
val find_index : t -> Monoid.Int.t -> id Option.t
val nth : t -> Monoid.Int.t -> id Option.t
val remove_index : t -> Monoid.Int.t -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:id ->
?less_or_equal_to:id -> t -> id Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:id ->
?less_or_equal_to:id ->
t ->
t ->
(id, id)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(id -> 'data) ->
(id, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
id Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
id Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : id -> t
val union_list : t List.t -> t
val of_list : id List.t -> t
val of_array : id array -> t
val of_sorted_array :
id array -> t Base__.Or_error.t
val of_sorted_array_unchecked : id array -> t
val of_increasing_iterator_unchecked :
len:Monoid.Int.t -> f:(Monoid.Int.t -> id) -> t
val stable_dedup_list : id List.t -> id List.t
val map : ('a, 'b) Base.Set.t -> f:('a -> id) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> id Option.t) -> t
val of_tree : Tree.t -> t
val of_hash_set : id Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(id, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(id, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
id Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> id
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : id Bin_prot.Type_class.t
val bin_read_t :
id Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> id)
Bin_prot.Read.reader
val bin_reader_t :
id Bin_prot.Type_class.reader
val bin_size_t :
id Bin_prot.Size.sizer
val bin_write_t :
id Bin_prot.Write.writer
val bin_writer_t :
id Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Monoid.Int.t -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t :
t Bin_prot.Type_class.writer
val bin_reader_t :
t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
id -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash :
t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Monoid.Int.t -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable :
t Core_kernel__.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel__.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, Monoid.Unit.t -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) List.t ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) List.t ->
[ `Duplicate_keys of key List.t | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b,
(key * 'b) List.t -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) List.t -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b List.t,
(key * 'b) List.t -> 'b List.t t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r List.t ->
[ `Duplicate_keys of key List.t | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r List.t ->
[ `Duplicate_keys of key List.t | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) ->
'r List.t -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r,
get_key:('r -> key) -> 'r List.t -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r List.t -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> Monoid.Unit.t
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c ->
f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys :
'a t -> f:(key -> Monoid.Unit.t) -> Monoid.Unit.t
val iter :
'b t -> f:('b -> Monoid.Unit.t) -> Monoid.Unit.t
val iteri :
'b t ->
f:(key:key -> data:'b -> Monoid.Unit.t) ->
Monoid.Unit.t
val iter_vals :
'b t -> f:('b -> Monoid.Unit.t) -> Monoid.Unit.t
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti :
'b t ->
f:(key:key -> data:'b -> bool) -> Monoid.Int.t
val count : 'b t -> f:('b -> bool) -> Monoid.Int.t
val length : 'a t -> Monoid.Int.t
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> Monoid.Unit.t
val replace :
'b t -> key:key -> data:'b -> Monoid.Unit.t
val set :
'b t -> key:key -> data:'b -> Monoid.Unit.t
val add :
'b t ->
key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t ->
key:key ->
data:'b -> Monoid.Unit.t Base__.Or_error.t
val add_exn :
'b t -> key:key -> data:'b -> Monoid.Unit.t
val change :
'b t ->
key ->
f:('b Option.t -> 'b Option.t) -> Monoid.Unit.t
val update :
'b t ->
key -> f:('b Option.t -> 'b) -> Monoid.Unit.t
val add_multi :
'b List.t t ->
key:key -> data:'b -> Monoid.Unit.t
val remove_multi :
'a List.t t -> key -> Monoid.Unit.t
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi :
'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map :
'b t -> f:('b -> 'c Option.t) -> 'c t
val filter_mapi :
'b t ->
f:(key:key -> data:'b -> 'c Option.t) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf :
'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t ->
f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add :
'b t ->
key -> default:(Monoid.Unit.t -> 'b) -> 'b
val find : 'b t -> key -> 'b Option.t
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) ->
if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b Option.t
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] -> 'c Option.t) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key ->
'a -> 'b Option.t -> 'b merge_into_action) ->
Monoid.Unit.t
val keys : 'a t -> key List.t
val data : 'b t -> 'b List.t
val filter_keys_inplace :
'a t -> f:(key -> bool) -> Monoid.Unit.t
val filter_inplace :
'b t -> f:('b -> bool) -> Monoid.Unit.t
val filteri_inplace :
'b t ->
f:(key:key -> data:'b -> bool) -> Monoid.Unit.t
val map_inplace :
'b t -> f:('b -> 'b) -> Monoid.Unit.t
val mapi_inplace :
'b t ->
f:(key:key -> data:'b -> 'b) -> Monoid.Unit.t
val filter_map_inplace :
'b t -> f:('b -> 'b Option.t) -> Monoid.Unit.t
val filter_mapi_inplace :
'b t ->
f:(key:key -> data:'b -> 'b Option.t) ->
Monoid.Unit.t
val replace_all :
'b t -> f:('b -> 'b) -> Monoid.Unit.t
val replace_alli :
'b t ->
f:(key:key -> data:'b -> 'b) -> Monoid.Unit.t
val filter_replace_all :
'b t -> f:('b -> 'b Option.t) -> Monoid.Unit.t
val filter_replace_alli :
'b t ->
f:(key:key -> data:'b -> 'b Option.t) ->
Monoid.Unit.t
val equal :
'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) List.t
val validate :
name:(key -> Monoid.String.t) ->
'b Base__.Validate.check ->
'b t Base__.Validate.check
val incr :
?by:Monoid.Int.t ->
?remove_if_zero:bool ->
Monoid.Int.t t -> key -> Monoid.Unit.t
val decr :
?by:Monoid.Int.t ->
?remove_if_zero:bool ->
Monoid.Int.t t -> key -> Monoid.Unit.t
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> key
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t :
key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t :
key Bin_prot.Size.sizer
val bin_write_t :
key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer ->
'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, Monoid.Int.t -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, Monoid.Unit.t -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt List.t -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig
val t_of_sexp : Sexplib.Sexp.t -> elt
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t :
elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t :
elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t :
t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t :
t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Monoid.Int.t -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = id
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> Monoid.Int.t
val hash : t -> Monoid.Int.t
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> Monoid.Int.t
val is_empty : 'a t -> bool
val iter :
'a t -> f:('a -> Monoid.Unit.t) -> Monoid.Unit.t
val fold :
'a t ->
init:'accum ->
f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop)
Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> Monoid.Int.t
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a Option.t
val find_map :
'a t -> f:('a -> 'b Option.t) -> 'b Option.t
val to_list : 'a t -> 'a List.t
val to_array : 'a t -> 'a array
val min_elt :
'a t ->
cmp:('a -> 'a -> Monoid.Int.t) -> 'a Option.t
val max_elt :
'a t ->
cmp:('a -> 'a -> Monoid.Int.t) -> 'a Option.t
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> id -> Core_kernel__.Import.bool
val lookup :
'a t -> id -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> id -> 'a
val enqueue :
'a t ->
id -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> id -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> id -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> id -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (id * 'a) Core_kernel__.Import.option
val keys : 'a t -> id Core_kernel__.Import.list
val dequeue :
'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (id * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> id * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> id -> [ `No_such_key | `Ok ]
val remove_exn :
'a t -> id -> Core_kernel__.Import.unit
val replace :
'a t -> id -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> id -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:id -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b ->
f:('b -> key:id -> data:'a -> 'b) -> 'b
end
val pp :
Format.formatter ->
Monads.Std.Monad.State.Multi.id -> unit
end
module type S =
sig
type 'a t
type 'a m
type 'a e
type id
module Id :
sig
type t = id
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val of_string : Monoid.String.t -> t
val to_string : t -> Monoid.String.t
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> Monoid.Int.t
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> Monoid.Int.t
val descending : t -> t -> Monoid.Int.t
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp :
t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t ->
t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t ->
t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t ->
t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> Monoid.Int.t
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = id
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t :
t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t :
t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness =
comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(id, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : id -> 'a -> 'a t
val of_alist :
(id * 'a) List.t ->
[ `Duplicate_key of id | `Ok of 'a t ]
val of_alist_or_error :
(id * 'a) List.t ->
'a t Base__.Or_error.t
val of_alist_exn : (id * 'a) List.t -> 'a t
val of_alist_multi :
(id * 'a) List.t -> 'a List.t t
val of_alist_fold :
(id * 'a) List.t ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(id * 'a) List.t ->
f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(id * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(id * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:Monoid.Int.t ->
f:(Monoid.Int.t -> id * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:id ->
data:'v -> Monoid.Unit.t) ->
Monoid.Unit.t) ->
[ `Duplicate_key of id | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(id, 'a) Core_kernel__.Core_hashtbl.t ->
'a t
val gen :
id Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> Monoid.Int.t
val add : 'a t -> key:id -> data:'a -> 'a t
val add_multi :
'a List.t t ->
key:id -> data:'a -> 'a List.t t
val remove_multi :
'a List.t t -> id -> 'a List.t t
val change :
'a t ->
id ->
f:('a Option.t -> 'a Option.t) -> 'a t
val update :
'a t ->
id -> f:('a Option.t -> 'a) -> 'a t
val find : 'a t -> id -> 'a Option.t
val find_exn : 'a t -> id -> 'a
val remove : 'a t -> id -> 'a t
val mem : 'a t -> id -> bool
val iter_keys :
'a t ->
f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
val iter :
'a t ->
f:('a -> Monoid.Unit.t) -> Monoid.Unit.t
val iteri :
'a t ->
f:(key:id -> data:'a -> Monoid.Unit.t) ->
Monoid.Unit.t
val iter2 :
'a t ->
'b t ->
f:(key:id ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
Monoid.Unit.t) ->
Monoid.Unit.t
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t ->
f:(key:id -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:id -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:id -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:id ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys :
'a t -> f:(id -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t ->
f:(key:id -> data:'a -> bool) -> 'a t
val filter_map :
'a t -> f:('a -> 'b Option.t) -> 'b t
val filter_mapi :
'a t ->
f:(key:id -> data:'a -> 'b Option.t) ->
'b t
val partition_mapi :
'a t ->
f:(key:id ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:id -> data:'a -> bool) ->
'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> Monoid.Int.t) ->
'a t -> 'a t -> Monoid.Int.t
val equal :
('a -> 'a -> bool) ->
'a t -> 'a t -> bool
val keys : 'a t -> id List.t
val data : 'a t -> 'a List.t
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (id * 'a) List.t
val validate :
name:(id -> Monoid.String.t) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:id ->
[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] -> 'c Option.t) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(id, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (id * 'a) Option.t
val min_elt_exn : 'a t -> id * 'a
val max_elt : 'a t -> (id * 'a) Option.t
val max_elt_exn : 'a t -> id * 'a
val for_all :
'a t -> f:('a -> bool) -> bool
val for_alli :
'a t ->
f:(key:id -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t ->
f:(key:id -> data:'a -> bool) -> bool
val count :
'a t -> f:('a -> bool) -> Monoid.Int.t
val counti :
'a t ->
f:(key:id -> data:'a -> bool) ->
Monoid.Int.t
val split :
'a t ->
id -> 'a t * (id * 'a) Option.t * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:id Base__.Maybe_bound.t ->
upper_bound:id Base__.Maybe_bound.t ->
'a t
val fold_range_inclusive :
'a t ->
min:id ->
max:id ->
init:'b ->
f:(key:id -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t ->
min:id -> max:id -> (id * 'a) List.t
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] ->
id -> (id * 'a) Option.t
val nth :
'a t ->
Monoid.Int.t -> (id * 'a) Option.t
val nth_exn :
'a t -> Monoid.Int.t -> id * 'a
val rank :
'a t -> id -> Monoid.Int.t Option.t
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key
| `Increasing_key ] ->
?keys_greater_or_equal_to:id ->
?keys_less_or_equal_to:id ->
'a t -> (id * 'a) Base__.Sequence.t
val obs :
id Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
id Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp :
Sexplib.Sexp.t -> id
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(id, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : id -> 'a -> 'a t
val of_alist :
(id * 'a) List.t ->
[ `Duplicate_key of id | `Ok of 'a t ]
val of_alist_or_error :
(id * 'a) List.t -> 'a t Base__.Or_error.t
val of_alist_exn : (id * 'a) List.t -> 'a t
val of_alist_multi :
(id * 'a) List.t -> 'a List.t t
val of_alist_fold :
(id * 'a) List.t ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(id * 'a) List.t ->
f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(id * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(id * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:Monoid.Int.t ->
f:(Monoid.Int.t -> id * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:id -> data:'v -> Monoid.Unit.t) ->
Monoid.Unit.t) ->
[ `Duplicate_key of id | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(id, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
id Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> Monoid.Int.t
val add : 'a t -> key:id -> data:'a -> 'a t
val add_multi :
'a List.t t ->
key:id -> data:'a -> 'a List.t t
val remove_multi :
'a List.t t -> id -> 'a List.t t
val change :
'a t ->
id -> f:('a Option.t -> 'a Option.t) -> 'a t
val update :
'a t -> id -> f:('a Option.t -> 'a) -> 'a t
val find : 'a t -> id -> 'a Option.t
val find_exn : 'a t -> id -> 'a
val remove : 'a t -> id -> 'a t
val mem : 'a t -> id -> bool
val iter_keys :
'a t ->
f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
val iter :
'a t ->
f:('a -> Monoid.Unit.t) -> Monoid.Unit.t
val iteri :
'a t ->
f:(key:id -> data:'a -> Monoid.Unit.t) ->
Monoid.Unit.t
val iter2 :
'a t ->
'b t ->
f:(key:id ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
Monoid.Unit.t) ->
Monoid.Unit.t
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:id -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:id -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:id -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:id ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys :
'a t -> f:(id -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:id -> data:'a -> bool) -> 'a t
val filter_map :
'a t -> f:('a -> 'b Option.t) -> 'b t
val filter_mapi :
'a t ->
f:(key:id -> data:'a -> 'b Option.t) -> 'b t
val partition_mapi :
'a t ->
f:(key:id ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:id -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> Monoid.Int.t) ->
'a t -> 'a t -> Monoid.Int.t
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> id List.t
val data : 'a t -> 'a List.t
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (id * 'a) List.t
val validate :
name:(id -> Monoid.String.t) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:id ->
[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] -> 'c Option.t) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(id, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (id * 'a) Option.t
val min_elt_exn : 'a t -> id * 'a
val max_elt : 'a t -> (id * 'a) Option.t
val max_elt_exn : 'a t -> id * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:id -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:id -> data:'a -> bool) -> bool
val count :
'a t -> f:('a -> bool) -> Monoid.Int.t
val counti :
'a t ->
f:(key:id -> data:'a -> bool) -> Monoid.Int.t
val split :
'a t ->
id -> 'a t * (id * 'a) Option.t * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:id Base__.Maybe_bound.t ->
upper_bound:id Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:id ->
max:id ->
init:'b ->
f:(key:id -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:id -> max:id -> (id * 'a) List.t
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> id -> (id * 'a) Option.t
val nth :
'a t -> Monoid.Int.t -> (id * 'a) Option.t
val nth_exn : 'a t -> Monoid.Int.t -> id * 'a
val rank : 'a t -> id -> Monoid.Int.t Option.t
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:id ->
?keys_less_or_equal_to:id ->
'a t -> (id * 'a) Base__.Sequence.t
val obs :
id Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
id Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp :
Sexplib.Sexp.t -> id
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t :
id Bin_prot.Type_class.t
val bin_read_t :
id Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> id)
Bin_prot.Read.reader
val bin_reader_t :
id Bin_prot.Type_class.reader
val bin_size_t :
id Bin_prot.Size.sizer
val bin_write_t :
id Bin_prot.Write.writer
val bin_writer_t :
id Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t :
('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t :
('a, 'a t) Bin_prot.Write.writer1
val bin_read_t :
('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, Monoid.Int.t -> 'a t)
Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t)
Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t)
Bin_prot.Type_class.S1.reader
val bin_t :
('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
id -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t :
('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t :
('a, 'a t) Bin_prot.Write.writer1
val bin_read_t :
('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, Monoid.Int.t -> 'a t)
Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = id
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t :
t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t :
t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness =
Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(id, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare :
t -> t -> Core_kernel__.Import.int
val length : t -> Monoid.Int.t
val is_empty : t -> bool
val iter :
t ->
f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
val fold :
t ->
init:'accum ->
f:('accum -> id -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum ->
id -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(id -> bool) -> bool
val for_all : t -> f:(id -> bool) -> bool
val count :
t -> f:(id -> bool) -> Monoid.Int.t
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(id -> 'sum) -> 'sum
val find :
t -> f:(id -> bool) -> id Option.t
val find_map :
t -> f:(id -> 'a Option.t) -> 'a Option.t
val to_list : t -> id List.t
val to_array : t -> id array
val invariants : t -> bool
val mem : t -> id -> bool
val add : t -> id -> t
val remove : t -> id -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(id, id) Base__.Either.t
Base__.Sequence.t
val compare_direct : t -> t -> Monoid.Int.t
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
id ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(id -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of id * id
| `Left of id
| `Right of id ] -> Monoid.Unit.t) ->
Monoid.Unit.t
val filter : t -> f:(id -> bool) -> t
val partition_tf :
t -> f:(id -> bool) -> t * t
val elements : t -> id List.t
val min_elt : t -> id Option.t
val min_elt_exn : t -> id
val max_elt : t -> id Option.t
val max_elt_exn : t -> id
val choose : t -> id Option.t
val choose_exn : t -> id
val split : t -> id -> t * id Option.t * t
val group_by :
t -> equiv:(id -> id -> bool) -> t List.t
val find_exn : t -> f:(id -> bool) -> id
val find_index :
t -> Monoid.Int.t -> id Option.t
val nth : t -> Monoid.Int.t -> id Option.t
val remove_index : t -> Monoid.Int.t -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:id ->
?less_or_equal_to:id ->
t -> id Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:id ->
?less_or_equal_to:id ->
t ->
t ->
(id, id)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(id -> 'data) ->
(id, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
id Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
id Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : id -> t
val union_list : t List.t -> t
val of_list : id List.t -> t
val of_array : id array -> t
val of_sorted_array :
id array -> t Base__.Or_error.t
val of_sorted_array_unchecked :
id array -> t
val of_increasing_iterator_unchecked :
len:Monoid.Int.t ->
f:(Monoid.Int.t -> id) -> t
val stable_dedup_list :
id List.t -> id List.t
val map :
('a, 'b)
Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> id) -> t
val filter_map :
('a, 'b)
Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> id Option.t) -> t
val of_tree : t -> t
val of_hash_set :
id Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(id, 'a) Core_kernel__.Core_hashtbl.t ->
t
val of_map_keys :
(id, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t ->
t
val gen :
id Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp :
Sexplib.Sexp.t -> id
end) ->
sig
val t_of_sexp : Sexplib.Sexp.t -> t
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (id, comparator_witness) Base.Set.t
val compare :
t -> t -> Core_kernel__.Import.int
val length : t -> Monoid.Int.t
val is_empty : t -> bool
val iter :
t -> f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
val fold :
t ->
init:'accum ->
f:('accum -> id -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum ->
id -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(id -> bool) -> bool
val for_all : t -> f:(id -> bool) -> bool
val count : t -> f:(id -> bool) -> Monoid.Int.t
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(id -> 'sum) -> 'sum
val find : t -> f:(id -> bool) -> id Option.t
val find_map :
t -> f:(id -> 'a Option.t) -> 'a Option.t
val to_list : t -> id List.t
val to_array : t -> id array
val invariants : t -> bool
val mem : t -> id -> bool
val add : t -> id -> t
val remove : t -> id -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(id, id) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> Monoid.Int.t
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
id ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(id -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of id * id
| `Left of id
| `Right of id ] -> Monoid.Unit.t) ->
Monoid.Unit.t
val filter : t -> f:(id -> bool) -> t
val partition_tf : t -> f:(id -> bool) -> t * t
val elements : t -> id List.t
val min_elt : t -> id Option.t
val min_elt_exn : t -> id
val max_elt : t -> id Option.t
val max_elt_exn : t -> id
val choose : t -> id Option.t
val choose_exn : t -> id
val split : t -> id -> t * id Option.t * t
val group_by :
t -> equiv:(id -> id -> bool) -> t List.t
val find_exn : t -> f:(id -> bool) -> id
val find_index :
t -> Monoid.Int.t -> id Option.t
val nth : t -> Monoid.Int.t -> id Option.t
val remove_index : t -> Monoid.Int.t -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:id ->
?less_or_equal_to:id ->
t -> id Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:id ->
?less_or_equal_to:id ->
t ->
t ->
(id, id)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(id -> 'data) ->
(id, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
id Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
id Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : id -> t
val union_list : t List.t -> t
val of_list : id List.t -> t
val of_array : id array -> t
val of_sorted_array :
id array -> t Base__.Or_error.t
val of_sorted_array_unchecked : id array -> t
val of_increasing_iterator_unchecked :
len:Monoid.Int.t ->
f:(Monoid.Int.t -> id) -> t
val stable_dedup_list : id List.t -> id List.t
val map :
('a, 'b) Base.Set.t -> f:('a -> id) -> t
val filter_map :
('a, 'b) Base.Set.t ->
f:('a -> id Option.t) -> t
val of_tree : Tree.t -> t
val of_hash_set :
id Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(id, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(id, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t ->
t
val gen :
id Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp :
Sexplib.Sexp.t -> id
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t :
id Bin_prot.Type_class.t
val bin_read_t :
id Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> id)
Bin_prot.Read.reader
val bin_reader_t :
id Bin_prot.Type_class.reader
val bin_size_t :
id Bin_prot.Size.sizer
val bin_write_t :
id Bin_prot.Write.writer
val bin_writer_t :
id Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Monoid.Int.t -> t)
Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t :
t Bin_prot.Type_class.writer
val bin_reader_t :
t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
id -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash :
t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Monoid.Int.t -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable :
t Core_kernel__.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Id.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) ->
'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key
Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, Monoid.Unit.t -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) List.t ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) List.t ->
[ `Duplicate_keys of key List.t
| `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b,
(key * 'b) List.t -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) List.t -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b List.t,
(key * 'b) List.t -> 'b List.t t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r List.t ->
[ `Duplicate_keys of key List.t
| `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r List.t ->
[ `Duplicate_keys of key List.t
| `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) ->
'r List.t -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r,
get_key:('r -> key) -> 'r List.t -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) ->
'r List.t -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> Monoid.Unit.t
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c ->
f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys :
'a t ->
f:(key -> Monoid.Unit.t) -> Monoid.Unit.t
val iter :
'b t ->
f:('b -> Monoid.Unit.t) -> Monoid.Unit.t
val iteri :
'b t ->
f:(key:key -> data:'b -> Monoid.Unit.t) ->
Monoid.Unit.t
val iter_vals :
'b t ->
f:('b -> Monoid.Unit.t) -> Monoid.Unit.t
val existsi :
'b t ->
f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t ->
f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti :
'b t ->
f:(key:key -> data:'b -> bool) ->
Monoid.Int.t
val count :
'b t -> f:('b -> bool) -> Monoid.Int.t
val length : 'a t -> Monoid.Int.t
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> Monoid.Unit.t
val replace :
'b t -> key:key -> data:'b -> Monoid.Unit.t
val set :
'b t -> key:key -> data:'b -> Monoid.Unit.t
val add :
'b t ->
key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t ->
key:key ->
data:'b -> Monoid.Unit.t Base__.Or_error.t
val add_exn :
'b t -> key:key -> data:'b -> Monoid.Unit.t
val change :
'b t ->
key ->
f:('b Option.t -> 'b Option.t) ->
Monoid.Unit.t
val update :
'b t ->
key -> f:('b Option.t -> 'b) -> Monoid.Unit.t
val add_multi :
'b List.t t ->
key:key -> data:'b -> Monoid.Unit.t
val remove_multi :
'a List.t t -> key -> Monoid.Unit.t
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi :
'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map :
'b t -> f:('b -> 'c Option.t) -> 'c t
val filter_mapi :
'b t ->
f:(key:key -> data:'b -> 'c Option.t) -> 'c t
val filter_keys :
'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t ->
f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf :
'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t ->
f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add :
'b t ->
key -> default:(Monoid.Unit.t -> 'b) -> 'b
val find : 'b t -> key -> 'b Option.t
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) ->
if_not_found:(key -> 'c) -> 'c
val find_and_remove :
'b t -> key -> 'b Option.t
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] -> 'c Option.t) ->
'c t
type 'a merge_into_action =
Remove
| Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key ->
'a -> 'b Option.t -> 'b merge_into_action) ->
Monoid.Unit.t
val keys : 'a t -> key List.t
val data : 'b t -> 'b List.t
val filter_keys_inplace :
'a t -> f:(key -> bool) -> Monoid.Unit.t
val filter_inplace :
'b t -> f:('b -> bool) -> Monoid.Unit.t
val filteri_inplace :
'b t ->
f:(key:key -> data:'b -> bool) ->
Monoid.Unit.t
val map_inplace :
'b t -> f:('b -> 'b) -> Monoid.Unit.t
val mapi_inplace :
'b t ->
f:(key:key -> data:'b -> 'b) -> Monoid.Unit.t
val filter_map_inplace :
'b t ->
f:('b -> 'b Option.t) -> Monoid.Unit.t
val filter_mapi_inplace :
'b t ->
f:(key:key -> data:'b -> 'b Option.t) ->
Monoid.Unit.t
val replace_all :
'b t -> f:('b -> 'b) -> Monoid.Unit.t
val replace_alli :
'b t ->
f:(key:key -> data:'b -> 'b) -> Monoid.Unit.t
val filter_replace_all :
'b t ->
f:('b -> 'b Option.t) -> Monoid.Unit.t
val filter_replace_alli :
'b t ->
f:(key:key -> data:'b -> 'b Option.t) ->
Monoid.Unit.t
val equal :
'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t ->
'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) List.t
val validate :
name:(key -> Monoid.String.t) ->
'b Base__.Validate.check ->
'b t Base__.Validate.check
val incr :
?by:Monoid.Int.t ->
?remove_if_zero:bool ->
Monoid.Int.t t -> key -> Monoid.Unit.t
val decr :
?by:Monoid.Int.t ->
?remove_if_zero:bool ->
Monoid.Int.t t -> key -> Monoid.Unit.t
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp :
Sexplib.Sexp.t -> key
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t :
key Bin_prot.Type_class.t
val bin_read_t :
key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t :
key Bin_prot.Size.sizer
val bin_write_t :
key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer ->
'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t :
('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t :
('a, 'a t) Bin_prot.Write.writer1
val bin_read_t :
('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, Monoid.Int.t -> 'a t)
Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, Monoid.Unit.t -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt List.t -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig
val t_of_sexp :
Sexplib.Sexp.t -> elt
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t :
elt Bin_prot.Type_class.t
val bin_read_t :
elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t :
elt Bin_prot.Size.sizer
val bin_write_t :
elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t :
t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t :
t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Monoid.Int.t -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = id
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> Monoid.Int.t
val hash : t -> Monoid.Int.t
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) ->
'a t -> Sexplib.Sexp.t
val length : 'a t -> Monoid.Int.t
val is_empty : 'a t -> bool
val iter :
'a t ->
f:('a -> Monoid.Unit.t) -> Monoid.Unit.t
val fold :
'a t ->
init:'accum ->
f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum ->
'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop)
Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count :
'a t -> f:('a -> bool) -> Monoid.Int.t
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find :
'a t -> f:('a -> bool) -> 'a Option.t
val find_map :
'a t -> f:('a -> 'b Option.t) -> 'b Option.t
val to_list : 'a t -> 'a List.t
val to_array : 'a t -> 'a array
val min_elt :
'a t ->
cmp:('a -> 'a -> Monoid.Int.t) -> 'a Option.t
val max_elt :
'a t ->
cmp:('a -> 'a -> Monoid.Int.t) -> 'a Option.t
val invariant :
'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem :
'a t -> id -> Core_kernel__.Import.bool
val lookup :
'a t -> id -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> id -> 'a
val enqueue :
'a t ->
id -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> id -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> id -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn :
'a t -> id -> 'a
val first :
'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (id * 'a) Core_kernel__.Import.option
val keys : 'a t -> id Core_kernel__.Import.list
val dequeue :
'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (id * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> id * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove :
'a t -> id -> [ `No_such_key | `Ok ]
val remove_exn :
'a t -> id -> Core_kernel__.Import.unit
val replace :
'a t -> id -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> id -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:id ->
data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b ->
f:('b -> key:id -> data:'a -> 'b) -> 'b
end
val pp :
Base__.Import.Caml.Format.formatter ->
t -> Monoid.Unit.t
end
val global : Monads.Std.Monad.State.Multi.S.id
val fork : unit -> unit t
val switch :
Monads.Std.Monad.State.Multi.S.id -> unit t
val parent :
unit -> Monads.Std.Monad.State.Multi.S.id t
val ancestor :
Monads.Std.Monad.State.Multi.S.id list ->
Monads.Std.Monad.State.Multi.S.id t
val current :
unit -> Monads.Std.Monad.State.Multi.S.id t
val kill : Monads.Std.Monad.State.Multi.S.id -> unit t
val forks :
unit ->
Monads.Std.Monad.State.Multi.S.id
Core_kernel.Std.Sequence.t t
val status :
Monads.Std.Monad.State.Multi.S.id ->
Monads.Std.Monad.State.Multi.status t
val lift : 'a m -> 'a t
val run : 'a t -> 'a e
val void : 'a t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t List.t -> Monoid.Unit.t t
val forever : 'a t -> 'b t
module Fn :
sig
val id : 'a -> 'a t
val ignore : 'a t -> Monoid.Unit.t t
val nothing : Monoid.Unit.t -> Monoid.Unit.t t
val non : ('a -> bool t) -> 'a -> bool t
val apply_n_times :
n:Monoid.Int.t -> ('a -> 'a t) -> 'a -> 'a t
val compose :
('b -> 'c t) -> ('a -> 'b t) -> 'a -> 'c t
end
module Pair :
sig
val fst : ('a * 'b) t -> 'a t
val snd : ('a * 'b) t -> 'b t
end
module Triple :
sig
val fst : ('a * 'b * 'c) t -> 'a t
val snd : ('a * 'b * 'c) t -> 'b t
val trd : ('a * 'b * 'c) t -> 'c t
end
module Lift :
sig
val nullary : 'a -> 'a t
val unary : ('a -> 'b) -> 'a t -> 'b t
val binary :
('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ternary :
('a -> 'b -> 'c -> 'd) ->
'a t -> 'b t -> 'c t -> 'd t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
f:(Monoid.Unit.t -> 'a t) ->
catch:(exn -> 'a t) -> 'a t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a t t -> 'a t t
val all_ignore : 'a t t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t t -> Monoid.Unit.t t
val map : 'a t -> f:('a -> 'b t) -> 'b t t
val iter :
'a t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a t -> f:('a -> bool t) -> bool t
val for_all :
'a t -> f:('a -> bool t) -> bool t
val count :
'a t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> 'a t) -> 'a t
val find :
'a t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter : 'a t -> f:('a -> bool t) -> 'a t t
val filter_map :
'a t -> f:('a -> 'b Option.t t) -> 'b t t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map :
'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) ->
Monoid.Unit.t t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t ->
f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists :
'a T.t -> f:('a -> bool t) -> bool t
val for_all :
'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t ->
f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a T.t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t ->
f:('a -> 'b Option.t t) -> 'b T.t t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map :
'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) ->
Monoid.Unit.t t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t ->
f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists :
'a T.t -> f:('a -> bool t) -> bool t
val for_all :
'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t ->
f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a T.t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t ->
f:('a -> 'b Option.t t) -> 'b T.t t
end
end
module List :
sig
val all : 'a t List.t -> 'a List.t t
val all_ignore : 'a t List.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t List.t -> Monoid.Unit.t t
val map :
'a List.t -> f:('a -> 'b t) -> 'b List.t t
val iter :
'a List.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a List.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a List.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a List.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a List.t ->
f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists :
'a List.t -> f:('a -> bool t) -> bool t
val for_all :
'a List.t -> f:('a -> bool t) -> bool t
val count :
'a List.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b List.t -> f:('b -> 'a t) -> 'a t
val find :
'a List.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a List.t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a List.t -> f:('a -> bool t) -> 'a List.t t
val filter_map :
'a List.t ->
f:('a -> 'b Option.t t) -> 'b List.t t
end
module Seq :
sig
val all : 'a t Seq.t -> 'a Seq.t t
val all_ignore : 'a t Seq.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t Seq.t -> Monoid.Unit.t t
val map : 'a Seq.t -> f:('a -> 'b t) -> 'b Seq.t t
val iter :
'a Seq.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a Seq.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a Seq.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a Seq.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a Seq.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a Seq.t -> f:('a -> bool t) -> bool t
val for_all :
'a Seq.t -> f:('a -> bool t) -> bool t
val count :
'a Seq.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Seq.t -> f:('b -> 'a t) -> 'a t
val find :
'a Seq.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a Seq.t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a Seq.t -> f:('a -> bool t) -> 'a Seq.t t
val filter_map :
'a Seq.t -> f:('a -> 'b Option.t t) -> 'b Seq.t t
end
val ( >=> ) :
('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Monad_infix :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
end
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val return : 'a -> 'a t
val map : 'a t -> f:('a -> 'b) -> 'b t
val join : 'a t t -> 'a t
val ignore_m : 'a t -> Monoid.Unit.t t
val all : 'a t list -> 'a list t
val all_ignore :
Monoid.Unit.t t list -> Monoid.Unit.t t
module Let_syntax :
sig
val return : 'a -> 'a t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Let_syntax :
sig
val return : 'a -> 'a t
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val map : 'a t -> f:('a -> 'b) -> 'b t
val both : 'a t -> 'b t -> ('a * 'b) t
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
val ( >=> ) :
('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) :
('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
type env
val put : env -> Monoid.Unit.t t
val get : Monoid.Unit.t -> env t
val gets : (env -> 'r) -> 'r t
val update : (env -> env) -> Monoid.Unit.t t
end
module type S2 =
sig
type ('a, 'e) t
type 'a m
type ('a, 'e) e
type id
module Id :
sig
type t = id
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val of_string : Monoid.String.t -> t
val to_string : t -> Monoid.String.t
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> Monoid.Int.t
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> Monoid.Int.t
val descending : t -> t -> Monoid.Int.t
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp :
t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t ->
t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t ->
t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t ->
t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> Monoid.Int.t
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = id
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t :
t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t :
t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness =
comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(id, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : id -> 'a -> 'a t
val of_alist :
(id * 'a) List.t ->
[ `Duplicate_key of id | `Ok of 'a t ]
val of_alist_or_error :
(id * 'a) List.t ->
'a t Base__.Or_error.t
val of_alist_exn : (id * 'a) List.t -> 'a t
val of_alist_multi :
(id * 'a) List.t -> 'a List.t t
val of_alist_fold :
(id * 'a) List.t ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(id * 'a) List.t ->
f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(id * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(id * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:Monoid.Int.t ->
f:(Monoid.Int.t -> id * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:id ->
data:'v -> Monoid.Unit.t) ->
Monoid.Unit.t) ->
[ `Duplicate_key of id | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(id, 'a) Core_kernel__.Core_hashtbl.t ->
'a t
val gen :
id Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> Monoid.Int.t
val add : 'a t -> key:id -> data:'a -> 'a t
val add_multi :
'a List.t t ->
key:id -> data:'a -> 'a List.t t
val remove_multi :
'a List.t t -> id -> 'a List.t t
val change :
'a t ->
id ->
f:('a Option.t -> 'a Option.t) -> 'a t
val update :
'a t ->
id -> f:('a Option.t -> 'a) -> 'a t
val find : 'a t -> id -> 'a Option.t
val find_exn : 'a t -> id -> 'a
val remove : 'a t -> id -> 'a t
val mem : 'a t -> id -> bool
val iter_keys :
'a t ->
f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
val iter :
'a t ->
f:('a -> Monoid.Unit.t) -> Monoid.Unit.t
val iteri :
'a t ->
f:(key:id -> data:'a -> Monoid.Unit.t) ->
Monoid.Unit.t
val iter2 :
'a t ->
'b t ->
f:(key:id ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
Monoid.Unit.t) ->
Monoid.Unit.t
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t ->
f:(key:id -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:id -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:id -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:id ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys :
'a t -> f:(id -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t ->
f:(key:id -> data:'a -> bool) -> 'a t
val filter_map :
'a t -> f:('a -> 'b Option.t) -> 'b t
val filter_mapi :
'a t ->
f:(key:id -> data:'a -> 'b Option.t) ->
'b t
val partition_mapi :
'a t ->
f:(key:id ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:id -> data:'a -> bool) ->
'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> Monoid.Int.t) ->
'a t -> 'a t -> Monoid.Int.t
val equal :
('a -> 'a -> bool) ->
'a t -> 'a t -> bool
val keys : 'a t -> id List.t
val data : 'a t -> 'a List.t
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (id * 'a) List.t
val validate :
name:(id -> Monoid.String.t) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:id ->
[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] -> 'c Option.t) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(id, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (id * 'a) Option.t
val min_elt_exn : 'a t -> id * 'a
val max_elt : 'a t -> (id * 'a) Option.t
val max_elt_exn : 'a t -> id * 'a
val for_all :
'a t -> f:('a -> bool) -> bool
val for_alli :
'a t ->
f:(key:id -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t ->
f:(key:id -> data:'a -> bool) -> bool
val count :
'a t -> f:('a -> bool) -> Monoid.Int.t
val counti :
'a t ->
f:(key:id -> data:'a -> bool) ->
Monoid.Int.t
val split :
'a t ->
id -> 'a t * (id * 'a) Option.t * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:id Base__.Maybe_bound.t ->
upper_bound:id Base__.Maybe_bound.t ->
'a t
val fold_range_inclusive :
'a t ->
min:id ->
max:id ->
init:'b ->
f:(key:id -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t ->
min:id -> max:id -> (id * 'a) List.t
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] ->
id -> (id * 'a) Option.t
val nth :
'a t ->
Monoid.Int.t -> (id * 'a) Option.t
val nth_exn :
'a t -> Monoid.Int.t -> id * 'a
val rank :
'a t -> id -> Monoid.Int.t Option.t
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key
| `Increasing_key ] ->
?keys_greater_or_equal_to:id ->
?keys_less_or_equal_to:id ->
'a t -> (id * 'a) Base__.Sequence.t
val obs :
id Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
id Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp :
Sexplib.Sexp.t -> id
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(id, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : id -> 'a -> 'a t
val of_alist :
(id * 'a) List.t ->
[ `Duplicate_key of id | `Ok of 'a t ]
val of_alist_or_error :
(id * 'a) List.t -> 'a t Base__.Or_error.t
val of_alist_exn : (id * 'a) List.t -> 'a t
val of_alist_multi :
(id * 'a) List.t -> 'a List.t t
val of_alist_fold :
(id * 'a) List.t ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(id * 'a) List.t ->
f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(id * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(id * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:Monoid.Int.t ->
f:(Monoid.Int.t -> id * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:id -> data:'v -> Monoid.Unit.t) ->
Monoid.Unit.t) ->
[ `Duplicate_key of id | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(id, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
id Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> Monoid.Int.t
val add : 'a t -> key:id -> data:'a -> 'a t
val add_multi :
'a List.t t ->
key:id -> data:'a -> 'a List.t t
val remove_multi :
'a List.t t -> id -> 'a List.t t
val change :
'a t ->
id -> f:('a Option.t -> 'a Option.t) -> 'a t
val update :
'a t -> id -> f:('a Option.t -> 'a) -> 'a t
val find : 'a t -> id -> 'a Option.t
val find_exn : 'a t -> id -> 'a
val remove : 'a t -> id -> 'a t
val mem : 'a t -> id -> bool
val iter_keys :
'a t ->
f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
val iter :
'a t ->
f:('a -> Monoid.Unit.t) -> Monoid.Unit.t
val iteri :
'a t ->
f:(key:id -> data:'a -> Monoid.Unit.t) ->
Monoid.Unit.t
val iter2 :
'a t ->
'b t ->
f:(key:id ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
Monoid.Unit.t) ->
Monoid.Unit.t
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:id -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:id -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:id -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:id ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys :
'a t -> f:(id -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:id -> data:'a -> bool) -> 'a t
val filter_map :
'a t -> f:('a -> 'b Option.t) -> 'b t
val filter_mapi :
'a t ->
f:(key:id -> data:'a -> 'b Option.t) -> 'b t
val partition_mapi :
'a t ->
f:(key:id ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:id -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> Monoid.Int.t) ->
'a t -> 'a t -> Monoid.Int.t
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> id List.t
val data : 'a t -> 'a List.t
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (id * 'a) List.t
val validate :
name:(id -> Monoid.String.t) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:id ->
[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] -> 'c Option.t) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(id, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (id * 'a) Option.t
val min_elt_exn : 'a t -> id * 'a
val max_elt : 'a t -> (id * 'a) Option.t
val max_elt_exn : 'a t -> id * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:id -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:id -> data:'a -> bool) -> bool
val count :
'a t -> f:('a -> bool) -> Monoid.Int.t
val counti :
'a t ->
f:(key:id -> data:'a -> bool) -> Monoid.Int.t
val split :
'a t ->
id -> 'a t * (id * 'a) Option.t * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:id Base__.Maybe_bound.t ->
upper_bound:id Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:id ->
max:id ->
init:'b ->
f:(key:id -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:id -> max:id -> (id * 'a) List.t
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> id -> (id * 'a) Option.t
val nth :
'a t -> Monoid.Int.t -> (id * 'a) Option.t
val nth_exn : 'a t -> Monoid.Int.t -> id * 'a
val rank : 'a t -> id -> Monoid.Int.t Option.t
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:id ->
?keys_less_or_equal_to:id ->
'a t -> (id * 'a) Base__.Sequence.t
val obs :
id Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
id Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp :
Sexplib.Sexp.t -> id
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t :
id Bin_prot.Type_class.t
val bin_read_t :
id Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> id)
Bin_prot.Read.reader
val bin_reader_t :
id Bin_prot.Type_class.reader
val bin_size_t :
id Bin_prot.Size.sizer
val bin_write_t :
id Bin_prot.Write.writer
val bin_writer_t :
id Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t :
('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t :
('a, 'a t) Bin_prot.Write.writer1
val bin_read_t :
('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, Monoid.Int.t -> 'a t)
Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t)
Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t)
Bin_prot.Type_class.S1.reader
val bin_t :
('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
id -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t :
('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t :
('a, 'a t) Bin_prot.Write.writer1
val bin_read_t :
('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, Monoid.Int.t -> 'a t)
Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = id
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t :
t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t :
t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness =
Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(id, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare :
t -> t -> Core_kernel__.Import.int
val length : t -> Monoid.Int.t
val is_empty : t -> bool
val iter :
t ->
f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
val fold :
t ->
init:'accum ->
f:('accum -> id -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum ->
id -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(id -> bool) -> bool
val for_all : t -> f:(id -> bool) -> bool
val count :
t -> f:(id -> bool) -> Monoid.Int.t
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(id -> 'sum) -> 'sum
val find :
t -> f:(id -> bool) -> id Option.t
val find_map :
t -> f:(id -> 'a Option.t) -> 'a Option.t
val to_list : t -> id List.t
val to_array : t -> id array
val invariants : t -> bool
val mem : t -> id -> bool
val add : t -> id -> t
val remove : t -> id -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(id, id) Base__.Either.t
Base__.Sequence.t
val compare_direct : t -> t -> Monoid.Int.t
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
id ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(id -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of id * id
| `Left of id
| `Right of id ] -> Monoid.Unit.t) ->
Monoid.Unit.t
val filter : t -> f:(id -> bool) -> t
val partition_tf :
t -> f:(id -> bool) -> t * t
val elements : t -> id List.t
val min_elt : t -> id Option.t
val min_elt_exn : t -> id
val max_elt : t -> id Option.t
val max_elt_exn : t -> id
val choose : t -> id Option.t
val choose_exn : t -> id
val split : t -> id -> t * id Option.t * t
val group_by :
t -> equiv:(id -> id -> bool) -> t List.t
val find_exn : t -> f:(id -> bool) -> id
val find_index :
t -> Monoid.Int.t -> id Option.t
val nth : t -> Monoid.Int.t -> id Option.t
val remove_index : t -> Monoid.Int.t -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:id ->
?less_or_equal_to:id ->
t -> id Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:id ->
?less_or_equal_to:id ->
t ->
t ->
(id, id)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(id -> 'data) ->
(id, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
id Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
id Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : id -> t
val union_list : t List.t -> t
val of_list : id List.t -> t
val of_array : id array -> t
val of_sorted_array :
id array -> t Base__.Or_error.t
val of_sorted_array_unchecked :
id array -> t
val of_increasing_iterator_unchecked :
len:Monoid.Int.t ->
f:(Monoid.Int.t -> id) -> t
val stable_dedup_list :
id List.t -> id List.t
val map :
('a, 'b)
Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> id) -> t
val filter_map :
('a, 'b)
Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> id Option.t) -> t
val of_tree : t -> t
val of_hash_set :
id Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(id, 'a) Core_kernel__.Core_hashtbl.t ->
t
val of_map_keys :
(id, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t ->
t
val gen :
id Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp :
Sexplib.Sexp.t -> id
end) ->
sig
val t_of_sexp : Sexplib.Sexp.t -> t
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (id, comparator_witness) Base.Set.t
val compare :
t -> t -> Core_kernel__.Import.int
val length : t -> Monoid.Int.t
val is_empty : t -> bool
val iter :
t -> f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
val fold :
t ->
init:'accum ->
f:('accum -> id -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum ->
id -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(id -> bool) -> bool
val for_all : t -> f:(id -> bool) -> bool
val count : t -> f:(id -> bool) -> Monoid.Int.t
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(id -> 'sum) -> 'sum
val find : t -> f:(id -> bool) -> id Option.t
val find_map :
t -> f:(id -> 'a Option.t) -> 'a Option.t
val to_list : t -> id List.t
val to_array : t -> id array
val invariants : t -> bool
val mem : t -> id -> bool
val add : t -> id -> t
val remove : t -> id -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(id, id) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> Monoid.Int.t
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
id ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(id -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of id * id
| `Left of id
| `Right of id ] -> Monoid.Unit.t) ->
Monoid.Unit.t
val filter : t -> f:(id -> bool) -> t
val partition_tf : t -> f:(id -> bool) -> t * t
val elements : t -> id List.t
val min_elt : t -> id Option.t
val min_elt_exn : t -> id
val max_elt : t -> id Option.t
val max_elt_exn : t -> id
val choose : t -> id Option.t
val choose_exn : t -> id
val split : t -> id -> t * id Option.t * t
val group_by :
t -> equiv:(id -> id -> bool) -> t List.t
val find_exn : t -> f:(id -> bool) -> id
val find_index :
t -> Monoid.Int.t -> id Option.t
val nth : t -> Monoid.Int.t -> id Option.t
val remove_index : t -> Monoid.Int.t -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:id ->
?less_or_equal_to:id ->
t -> id Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:id ->
?less_or_equal_to:id ->
t ->
t ->
(id, id)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(id -> 'data) ->
(id, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
id Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
id Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : id -> t
val union_list : t List.t -> t
val of_list : id List.t -> t
val of_array : id array -> t
val of_sorted_array :
id array -> t Base__.Or_error.t
val of_sorted_array_unchecked : id array -> t
val of_increasing_iterator_unchecked :
len:Monoid.Int.t ->
f:(Monoid.Int.t -> id) -> t
val stable_dedup_list : id List.t -> id List.t
val map :
('a, 'b) Base.Set.t -> f:('a -> id) -> t
val filter_map :
('a, 'b) Base.Set.t ->
f:('a -> id Option.t) -> t
val of_tree : Tree.t -> t
val of_hash_set :
id Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(id, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(id, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t ->
t
val gen :
id Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp :
Sexplib.Sexp.t -> id
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t :
id Bin_prot.Type_class.t
val bin_read_t :
id Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> id)
Bin_prot.Read.reader
val bin_reader_t :
id Bin_prot.Type_class.reader
val bin_size_t :
id Bin_prot.Size.sizer
val bin_write_t :
id Bin_prot.Write.writer
val bin_writer_t :
id Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Monoid.Int.t -> t)
Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t :
t Bin_prot.Type_class.writer
val bin_reader_t :
t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
id -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash :
t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Monoid.Int.t -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable :
t Core_kernel__.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Id.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) ->
'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key
Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, Monoid.Unit.t -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) List.t ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) List.t ->
[ `Duplicate_keys of key List.t
| `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b,
(key * 'b) List.t -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) List.t -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b List.t,
(key * 'b) List.t -> 'b List.t t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r List.t ->
[ `Duplicate_keys of key List.t
| `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r List.t ->
[ `Duplicate_keys of key List.t
| `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) ->
'r List.t -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r,
get_key:('r -> key) -> 'r List.t -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) ->
'r List.t -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> Monoid.Unit.t
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c ->
f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys :
'a t ->
f:(key -> Monoid.Unit.t) -> Monoid.Unit.t
val iter :
'b t ->
f:('b -> Monoid.Unit.t) -> Monoid.Unit.t
val iteri :
'b t ->
f:(key:key -> data:'b -> Monoid.Unit.t) ->
Monoid.Unit.t
val iter_vals :
'b t ->
f:('b -> Monoid.Unit.t) -> Monoid.Unit.t
val existsi :
'b t ->
f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t ->
f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti :
'b t ->
f:(key:key -> data:'b -> bool) ->
Monoid.Int.t
val count :
'b t -> f:('b -> bool) -> Monoid.Int.t
val length : 'a t -> Monoid.Int.t
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> Monoid.Unit.t
val replace :
'b t -> key:key -> data:'b -> Monoid.Unit.t
val set :
'b t -> key:key -> data:'b -> Monoid.Unit.t
val add :
'b t ->
key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t ->
key:key ->
data:'b -> Monoid.Unit.t Base__.Or_error.t
val add_exn :
'b t -> key:key -> data:'b -> Monoid.Unit.t
val change :
'b t ->
key ->
f:('b Option.t -> 'b Option.t) ->
Monoid.Unit.t
val update :
'b t ->
key -> f:('b Option.t -> 'b) -> Monoid.Unit.t
val add_multi :
'b List.t t ->
key:key -> data:'b -> Monoid.Unit.t
val remove_multi :
'a List.t t -> key -> Monoid.Unit.t
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi :
'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map :
'b t -> f:('b -> 'c Option.t) -> 'c t
val filter_mapi :
'b t ->
f:(key:key -> data:'b -> 'c Option.t) -> 'c t
val filter_keys :
'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t ->
f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf :
'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t ->
f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add :
'b t ->
key -> default:(Monoid.Unit.t -> 'b) -> 'b
val find : 'b t -> key -> 'b Option.t
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) ->
if_not_found:(key -> 'c) -> 'c
val find_and_remove :
'b t -> key -> 'b Option.t
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] -> 'c Option.t) ->
'c t
type 'a merge_into_action =
Remove
| Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key ->
'a -> 'b Option.t -> 'b merge_into_action) ->
Monoid.Unit.t
val keys : 'a t -> key List.t
val data : 'b t -> 'b List.t
val filter_keys_inplace :
'a t -> f:(key -> bool) -> Monoid.Unit.t
val filter_inplace :
'b t -> f:('b -> bool) -> Monoid.Unit.t
val filteri_inplace :
'b t ->
f:(key:key -> data:'b -> bool) ->
Monoid.Unit.t
val map_inplace :
'b t -> f:('b -> 'b) -> Monoid.Unit.t
val mapi_inplace :
'b t ->
f:(key:key -> data:'b -> 'b) -> Monoid.Unit.t
val filter_map_inplace :
'b t ->
f:('b -> 'b Option.t) -> Monoid.Unit.t
val filter_mapi_inplace :
'b t ->
f:(key:key -> data:'b -> 'b Option.t) ->
Monoid.Unit.t
val replace_all :
'b t -> f:('b -> 'b) -> Monoid.Unit.t
val replace_alli :
'b t ->
f:(key:key -> data:'b -> 'b) -> Monoid.Unit.t
val filter_replace_all :
'b t ->
f:('b -> 'b Option.t) -> Monoid.Unit.t
val filter_replace_alli :
'b t ->
f:(key:key -> data:'b -> 'b Option.t) ->
Monoid.Unit.t
val equal :
'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t ->
'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) List.t
val validate :
name:(key -> Monoid.String.t) ->
'b Base__.Validate.check ->
'b t Base__.Validate.check
val incr :
?by:Monoid.Int.t ->
?remove_if_zero:bool ->
Monoid.Int.t t -> key -> Monoid.Unit.t
val decr :
?by:Monoid.Int.t ->
?remove_if_zero:bool ->
Monoid.Int.t t -> key -> Monoid.Unit.t
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp :
Sexplib.Sexp.t -> key
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t :
key Bin_prot.Type_class.t
val bin_read_t :
key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t :
key Bin_prot.Size.sizer
val bin_write_t :
key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer ->
'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t :
('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t :
('a, 'a t) Bin_prot.Write.writer1
val bin_read_t :
('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, Monoid.Int.t -> 'a t)
Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, Monoid.Unit.t -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt List.t -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig
val t_of_sexp :
Sexplib.Sexp.t -> elt
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t :
elt Bin_prot.Type_class.t
val bin_read_t :
elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t :
elt Bin_prot.Size.sizer
val bin_write_t :
elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t :
t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t :
t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Monoid.Int.t -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = id
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> Monoid.Int.t
val hash : t -> Monoid.Int.t
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) ->
'a t -> Sexplib.Sexp.t
val length : 'a t -> Monoid.Int.t
val is_empty : 'a t -> bool
val iter :
'a t ->
f:('a -> Monoid.Unit.t) -> Monoid.Unit.t
val fold :
'a t ->
init:'accum ->
f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum ->
'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop)
Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count :
'a t -> f:('a -> bool) -> Monoid.Int.t
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find :
'a t -> f:('a -> bool) -> 'a Option.t
val find_map :
'a t -> f:('a -> 'b Option.t) -> 'b Option.t
val to_list : 'a t -> 'a List.t
val to_array : 'a t -> 'a array
val min_elt :
'a t ->
cmp:('a -> 'a -> Monoid.Int.t) -> 'a Option.t
val max_elt :
'a t ->
cmp:('a -> 'a -> Monoid.Int.t) -> 'a Option.t
val invariant :
'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem :
'a t -> id -> Core_kernel__.Import.bool
val lookup :
'a t -> id -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> id -> 'a
val enqueue :
'a t ->
id -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> id -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> id -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn :
'a t -> id -> 'a
val first :
'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (id * 'a) Core_kernel__.Import.option
val keys : 'a t -> id Core_kernel__.Import.list
val dequeue :
'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (id * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> id * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove :
'a t -> id -> [ `No_such_key | `Ok ]
val remove_exn :
'a t -> id -> Core_kernel__.Import.unit
val replace :
'a t -> id -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> id -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:id ->
data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b ->
f:('b -> key:id -> data:'a -> 'b) -> 'b
end
val pp :
Base__.Import.Caml.Format.formatter ->
t -> Monoid.Unit.t
end
val global : Monads.Std.Monad.State.Multi.S2.id
val fork : unit -> (unit, 'e) t
val switch :
Monads.Std.Monad.State.Multi.S2.id -> (unit, 'e) t
val parent :
unit -> (Monads.Std.Monad.State.Multi.S2.id, 'e) t
val ancestor :
Monads.Std.Monad.State.Multi.S2.id list ->
(Monads.Std.Monad.State.Multi.S2.id, 'e) t
val current :
unit -> (Monads.Std.Monad.State.Multi.S2.id, 'e) t
val kill :
Monads.Std.Monad.State.Multi.S2.id -> (unit, 'e) t
val forks :
unit ->
(Monads.Std.Monad.State.Multi.S2.id
Core_kernel.Std.Sequence.t, 'e)
t
val status :
Monads.Std.Monad.State.Multi.S2.id ->
(Monads.Std.Monad.State.Multi.status, 'e) t
val lift : 'a m -> ('a, 'e) t
val run : ('a, 'e) t -> ('a, 'e) e
val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
val forever : ('a, 'e) t -> ('b, 'e) t
module Fn :
sig
val id : 'a -> ('a, 'e) t
val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val nothing :
Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
val non :
('a -> (bool, 'e) t) -> 'a -> (bool, 'e) t
val apply_n_times :
n:Monoid.Int.t ->
('a -> ('a, 'e) t) -> 'a -> ('a, 'e) t
val compose :
('b -> ('c, 'e) t) ->
('a -> ('b, 'e) t) -> 'a -> ('c, 'e) t
end
module Pair :
sig
val fst : ('a * 'b, 'e) t -> ('a, 'e) t
val snd : ('a * 'b, 'e) t -> ('b, 'e) t
end
module Triple :
sig
val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
end
module Lift :
sig
val nullary : 'a -> ('a, 'e) t
val unary : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val binary :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ternary :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t ->
('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t ->
('d, 's) t -> ('e, 's) t -> ('f, 's) t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
f:(Monoid.Unit.t -> ('a, 's) t) ->
catch:(exn -> ('a, 's) t) -> ('a, 's) t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : ('a, 'e) t t -> ('a t, 'e) t
val all_ignore :
('a, 'e) t t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t t ->
(Monoid.Unit.t, 'e) t
val map :
'a t -> f:('a -> ('b, 'e) t) -> ('b t, 'e) t
val iter :
'a t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a t ->
f:('a -> 'a -> ('a, 'e) t) ->
('a Option.t, 'e) t
val exists :
'a t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a t ->
f:('a -> (bool, 'e) t) ->
(Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a t ->
f:('a -> (bool, 'e) t) -> ('a t, 'e) t
val filter_map :
'a t ->
f:('a -> ('b Option.t, 'e) t) -> ('b t, 'e) t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : ('a, 'e) t T.t -> ('a T.t, 'e) t
val all_ignore :
('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t T.t ->
(Monoid.Unit.t, 'e) t
val map :
'a T.t ->
f:('a -> ('b, 'e) t) -> ('b T.t, 'e) t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) t) ->
('a Option.t, 'e) t
val exists :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a T.t ->
f:('a -> (bool, 'e) t) ->
(Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a T.t ->
f:('a -> (bool, 'e) t) ->
('a Option.t, 'e) t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a T.t, 'e) t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) ->
('b T.t, 'e) t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : ('a, 'e) t T.t -> ('a T.t, 'e) t
val all_ignore :
('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t T.t ->
(Monoid.Unit.t, 'e) t
val map :
'a T.t ->
f:('a -> ('b, 'e) t) -> ('b T.t, 'e) t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) t) ->
('a Option.t, 'e) t
val exists :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a T.t ->
f:('a -> (bool, 'e) t) ->
(Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a T.t ->
f:('a -> (bool, 'e) t) ->
('a Option.t, 'e) t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a T.t, 'e) t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) ->
('b T.t, 'e) t
end
end
module List :
sig
val all : ('a, 'e) t List.t -> ('a List.t, 'e) t
val all_ignore :
('a, 'e) t List.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t List.t ->
(Monoid.Unit.t, 'e) t
val map :
'a List.t ->
f:('a -> ('b, 'e) t) -> ('b List.t, 'e) t
val iter :
'a List.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a List.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a List.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a List.t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a List.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a List.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a List.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a List.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b List.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a List.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a List.t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a List.t ->
f:('a -> (bool, 'e) t) -> ('a List.t, 'e) t
val filter_map :
'a List.t ->
f:('a -> ('b Option.t, 'e) t) ->
('b List.t, 'e) t
end
module Seq :
sig
val all : ('a, 'e) t Seq.t -> ('a Seq.t, 'e) t
val all_ignore :
('a, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t Seq.t ->
(Monoid.Unit.t, 'e) t
val map :
'a Seq.t ->
f:('a -> ('b, 'e) t) -> ('b Seq.t, 'e) t
val iter :
'a Seq.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a Seq.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a Seq.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a Seq.t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a Seq.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a Seq.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a Seq.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a Seq.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Seq.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a Seq.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a Seq.t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a Seq.t ->
f:('a -> (bool, 'e) t) -> ('a Seq.t, 'e) t
val filter_map :
'a Seq.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b Seq.t, 'e) t
end
val ( >=> ) :
('a -> ('b, 'e) t) ->
('b -> ('c, 'e) t) -> 'a -> ('c, 'e) t
val ( !! ) : 'a -> ('a, 'e) t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) :
('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val bind :
('a, 'e) t ->
f:('a -> ('b, 'e) t) -> ('b, 'e) t
val map :
('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val both :
('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) :
('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
end
val bind :
('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val return : 'a -> ('a, 'b) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore :
(Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
module Syntax :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) :
('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
val ( >=> ) :
('a -> ('b, 'e) t) ->
('b -> ('c, 'e) t) -> 'a -> ('c, 'e) t
val ( !! ) : 'a -> ('a, 'e) t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t ->
('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t ->
('d, 's) t -> ('e, 's) t -> ('f, 's) t
end
val put : 's -> (Monoid.Unit.t, 's) t
val get : Monoid.Unit.t -> ('s, 's) t
val gets : ('s -> 'r) -> ('r, 's) t
val update : ('s -> 's) -> (Monoid.Unit.t, 's) t
end
module T1 :
functor (T : Core_kernel.Std.T) (M : Monad) ->
sig
type env = T.t
type 'a m = 'a M.t
type 'a t =
(('a,
Monads.Std.Monad.State.Multi.T1.env
Monads.Std.Monad.State.Multi.contexts)
Monads.Std.Monad.State.storage
Monads.Std.Monad.State.Multi.T1.m,
Monads.Std.Monad.State.Multi.T1.env
Monads.Std.Monad.State.Multi.contexts)
Monads.Std.Monad.State.state
type 'a e =
Monads.Std.Monad.State.Multi.T1.env ->
('a * Monads.Std.Monad.State.Multi.T1.env)
Monads.Std.Monad.State.Multi.T1.m
end
module T2 :
functor (M : Monad) ->
sig
type 'a m = 'a M.t
type ('a, 'e) t =
(('a, 'e Monads.Std.Monad.State.Multi.contexts)
Monads.Std.Monad.State.storage
Monads.Std.Monad.State.Multi.T2.m,
'e Monads.Std.Monad.State.Multi.contexts)
Monads.Std.Monad.State.state
type ('a, 'e) e =
'e -> ('a * 'e) Monads.Std.Monad.State.Multi.T2.m
end
module Make :
functor (T : Core_kernel.Std.T) (M : Monad) ->
sig
val global : id
val fork : Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t
val switch : id -> Monoid.Unit.t T1(T)(M).t
val parent : Monoid.Unit.t -> id T1(T)(M).t
val ancestor : id List.t -> id T1(T)(M).t
val current : Monoid.Unit.t -> id T1(T)(M).t
val kill : id -> Monoid.Unit.t T1(T)(M).t
val forks : Monoid.Unit.t -> id Seq.t T1(T)(M).t
val status : id -> status T1(T)(M).t
val lift : 'a M.t -> 'a T1(T)(M).t
val run : 'a T1(T)(M).t -> 'a T1(T)(M).e
val void : 'a T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t List.t ->
Monoid.Unit.t T1(T)(M).t
val forever : 'a T1(T)(M).t -> 'b T1(T)(M).t
module Fn :
sig
val id : 'a -> 'a T1(T)(M).t
val ignore :
'a T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
val nothing :
Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t
val non :
('a -> bool T1(T)(M).t) ->
'a -> bool T1(T)(M).t
val apply_n_times :
n:Monoid.Int.t ->
('a -> 'a T1(T)(M).t) -> 'a -> 'a T1(T)(M).t
val compose :
('b -> 'c T1(T)(M).t) ->
('a -> 'b T1(T)(M).t) -> 'a -> 'c T1(T)(M).t
end
module Pair :
sig
val fst : ('a * 'b) T1(T)(M).t -> 'a T1(T)(M).t
val snd : ('a * 'b) T1(T)(M).t -> 'b T1(T)(M).t
end
module Triple :
sig
val fst :
('a * 'b * 'c) T1(T)(M).t -> 'a T1(T)(M).t
val snd :
('a * 'b * 'c) T1(T)(M).t -> 'b T1(T)(M).t
val trd :
('a * 'b * 'c) T1(T)(M).t -> 'c T1(T)(M).t
end
module Lift :
sig
val nullary : 'a -> 'a T1(T)(M).t
val unary :
('a -> 'b) -> 'a T1(T)(M).t -> 'b T1(T)(M).t
val binary :
('a -> 'b -> 'c) ->
'a T1(T)(M).t -> 'b T1(T)(M).t -> 'c T1(T)(M).t
val ternary :
('a -> 'b -> 'c -> 'd) ->
'a T1(T)(M).t ->
'b T1(T)(M).t -> 'c T1(T)(M).t -> 'd T1(T)(M).t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t -> 'd T1(T)(M).t -> 'e T1(T)(M).t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t ->
'd T1(T)(M).t -> 'e T1(T)(M).t -> 'f T1(T)(M).t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t ->
Monoid.Unit.t T1(T)(M).t) ->
f:(Monoid.Unit.t -> 'a T1(T)(M).t) ->
catch:(exn -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a T1(T)(M).t t -> 'a t T1(T)(M).t
val all_ignore :
'a T1(T)(M).t t -> Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t t ->
Monoid.Unit.t T1(T)(M).t
val map :
'a t ->
f:('a -> 'b T1(T)(M).t) -> 'b t T1(T)(M).t
val iter :
'a t ->
f:('a -> Monoid.Unit.t T1(T)(M).t) ->
Monoid.Unit.t T1(T)(M).t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) ->
'b T1(T)(M).t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) ->
'b T1(T)(M).t
val fold_right :
'a t ->
f:('a -> 'b -> 'b T1(T)(M).t) ->
init:'b -> 'b T1(T)(M).t
val reduce :
'a t ->
f:('a -> 'a -> 'a T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val exists :
'a t ->
f:('a -> bool T1(T)(M).t) ->
bool T1(T)(M).t
val for_all :
'a t ->
f:('a -> bool T1(T)(M).t) ->
bool T1(T)(M).t
val count :
'a t ->
f:('a -> bool T1(T)(M).t) ->
Monoid.Int.t T1(T)(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t ->
f:('b -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
val find :
'a t ->
f:('a -> bool T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val find_map :
'a t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Option.t T1(T)(M).t
val filter :
'a t ->
f:('a -> bool T1(T)(M).t) ->
'a t T1(T)(M).t
val filter_map :
'a t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b t T1(T)(M).t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all :
'a T1(T)(M).t T.t -> 'a T.t T1(T)(M).t
val all_ignore :
'a T1(T)(M).t T.t ->
Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t T.t ->
Monoid.Unit.t T1(T)(M).t
val map :
'a T.t ->
f:('a -> 'b T1(T)(M).t) ->
'b T.t T1(T)(M).t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t T1(T)(M).t) ->
Monoid.Unit.t T1(T)(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) ->
'b T1(T)(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) ->
'b T1(T)(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b T1(T)(M).t) ->
init:'b -> 'b T1(T)(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> 'a T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val exists :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
bool T1(T)(M).t
val for_all :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
bool T1(T)(M).t
val count :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
Monoid.Int.t T1(T)(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
val find :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val find_map :
'a T.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Option.t T1(T)(M).t
val filter :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
'a T.t T1(T)(M).t
val filter_map :
'a T.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b T.t T1(T)(M).t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all :
'a T1(T)(M).t T.t -> 'a T.t T1(T)(M).t
val all_ignore :
'a T1(T)(M).t T.t ->
Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t T.t ->
Monoid.Unit.t T1(T)(M).t
val map :
'a T.t ->
f:('a -> 'b T1(T)(M).t) ->
'b T.t T1(T)(M).t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t T1(T)(M).t) ->
Monoid.Unit.t T1(T)(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) ->
'b T1(T)(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) ->
'b T1(T)(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b T1(T)(M).t) ->
init:'b -> 'b T1(T)(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> 'a T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val exists :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
bool T1(T)(M).t
val for_all :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
bool T1(T)(M).t
val count :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
Monoid.Int.t T1(T)(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
val find :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val find_map :
'a T.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Option.t T1(T)(M).t
val filter :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
'a T.t T1(T)(M).t
val filter_map :
'a T.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b T.t T1(T)(M).t
end
end
module List :
sig
val all :
'a T1(T)(M).t List.t -> 'a List.t T1(T)(M).t
val all_ignore :
'a T1(T)(M).t List.t ->
Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t List.t ->
Monoid.Unit.t T1(T)(M).t
val map :
'a List.t ->
f:('a -> 'b T1(T)(M).t) -> 'b List.t T1(T)(M).t
val iter :
'a List.t ->
f:('a -> Monoid.Unit.t T1(T)(M).t) ->
Monoid.Unit.t T1(T)(M).t
val fold :
'a List.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_left :
'a List.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_right :
'a List.t ->
f:('a -> 'b -> 'b T1(T)(M).t) ->
init:'b -> 'b T1(T)(M).t
val reduce :
'a List.t ->
f:('a -> 'a -> 'a T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val exists :
'a List.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val for_all :
'a List.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val count :
'a List.t ->
f:('a -> bool T1(T)(M).t) ->
Monoid.Int.t T1(T)(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b List.t ->
f:('b -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
val find :
'a List.t ->
f:('a -> bool T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val find_map :
'a List.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Option.t T1(T)(M).t
val filter :
'a List.t ->
f:('a -> bool T1(T)(M).t) ->
'a List.t T1(T)(M).t
val filter_map :
'a List.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b List.t T1(T)(M).t
end
module Seq :
sig
val all :
'a T1(T)(M).t Seq.t -> 'a Seq.t T1(T)(M).t
val all_ignore :
'a T1(T)(M).t Seq.t -> Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t Seq.t ->
Monoid.Unit.t T1(T)(M).t
val map :
'a Seq.t ->
f:('a -> 'b T1(T)(M).t) -> 'b Seq.t T1(T)(M).t
val iter :
'a Seq.t ->
f:('a -> Monoid.Unit.t T1(T)(M).t) ->
Monoid.Unit.t T1(T)(M).t
val fold :
'a Seq.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_left :
'a Seq.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_right :
'a Seq.t ->
f:('a -> 'b -> 'b T1(T)(M).t) ->
init:'b -> 'b T1(T)(M).t
val reduce :
'a Seq.t ->
f:('a -> 'a -> 'a T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val exists :
'a Seq.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val for_all :
'a Seq.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val count :
'a Seq.t ->
f:('a -> bool T1(T)(M).t) ->
Monoid.Int.t T1(T)(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Seq.t ->
f:('b -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
val find :
'a Seq.t ->
f:('a -> bool T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val find_map :
'a Seq.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Option.t T1(T)(M).t
val filter :
'a Seq.t ->
f:('a -> bool T1(T)(M).t) ->
'a Seq.t T1(T)(M).t
val filter_map :
'a Seq.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Seq.t T1(T)(M).t
end
val ( >=> ) :
('a -> 'b T1(T)(M).t) ->
('b -> 'c T1(T)(M).t) -> 'a -> 'c T1(T)(M).t
val ( !! ) : 'a -> 'a T1(T)(M).t
val ( !$ ) :
('a -> 'b) -> 'a T1(T)(M).t -> 'b T1(T)(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
'a T1(T)(M).t -> 'b T1(T)(M).t -> 'c T1(T)(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a T1(T)(M).t ->
'b T1(T)(M).t -> 'c T1(T)(M).t -> 'd T1(T)(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t -> 'd T1(T)(M).t -> 'e T1(T)(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t ->
'd T1(T)(M).t -> 'e T1(T)(M).t -> 'f T1(T)(M).t
val ( >>= ) :
'a T1(T)(M).t ->
('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val ( >>| ) :
'a T1(T)(M).t -> ('a -> 'b) -> 'b T1(T)(M).t
module Monad_infix :
sig
val ( >>= ) :
'a T1(T)(M).t ->
('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val ( >>| ) :
'a T1(T)(M).t -> ('a -> 'b) -> 'b T1(T)(M).t
end
val bind :
'a T1(T)(M).t ->
f:('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val return : 'a -> 'a T1(T)(M).t
val map :
'a T1(T)(M).t -> f:('a -> 'b) -> 'b T1(T)(M).t
val join : 'a T1(T)(M).t T1(T)(M).t -> 'a T1(T)(M).t
val ignore_m :
'a T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
val all : 'a T1(T)(M).t list -> 'a list T1(T)(M).t
val all_ignore :
Monoid.Unit.t T1(T)(M).t list ->
Monoid.Unit.t T1(T)(M).t
module Let_syntax :
sig
val return : 'a -> 'a T1(T)(M).t
val ( >>= ) :
'a T1(T)(M).t ->
('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val ( >>| ) :
'a T1(T)(M).t -> ('a -> 'b) -> 'b T1(T)(M).t
module Let_syntax :
sig
val return : 'a -> 'a T1(T)(M).t
val bind :
'a T1(T)(M).t ->
f:('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val map :
'a T1(T)(M).t ->
f:('a -> 'b) -> 'b T1(T)(M).t
val both :
'a T1(T)(M).t ->
'b T1(T)(M).t -> ('a * 'b) T1(T)(M).t
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) :
'a T1(T)(M).t ->
('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val ( >>| ) :
'a T1(T)(M).t -> ('a -> 'b) -> 'b T1(T)(M).t
val ( >=> ) :
('a -> 'b T1(T)(M).t) ->
('b -> 'c T1(T)(M).t) -> 'a -> 'c T1(T)(M).t
val ( !! ) : 'a -> 'a T1(T)(M).t
val ( !$ ) :
('a -> 'b) -> 'a T1(T)(M).t -> 'b T1(T)(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
'a T1(T)(M).t -> 'b T1(T)(M).t -> 'c T1(T)(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a T1(T)(M).t ->
'b T1(T)(M).t -> 'c T1(T)(M).t -> 'd T1(T)(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t -> 'd T1(T)(M).t -> 'e T1(T)(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t ->
'd T1(T)(M).t -> 'e T1(T)(M).t -> 'f T1(T)(M).t
end
val put : T.t -> Monoid.Unit.t T1(T)(M).t
val get : Monoid.Unit.t -> T.t T1(T)(M).t
val gets : (T.t -> 'r) -> 'r T1(T)(M).t
val update : (T.t -> T.t) -> Monoid.Unit.t T1(T)(M).t
end
module Make2 :
functor (M : Monad) ->
sig
val global : id
val fork :
Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
val switch : id -> (Monoid.Unit.t, 'e) T2(M).t
val parent : Monoid.Unit.t -> (id, 'e) T2(M).t
val ancestor : id List.t -> (id, 'e) T2(M).t
val current : Monoid.Unit.t -> (id, 'e) T2(M).t
val kill : id -> (Monoid.Unit.t, 'e) T2(M).t
val forks : Monoid.Unit.t -> (id Seq.t, 'e) T2(M).t
val status : id -> (status, 'e) T2(M).t
val lift : 'a M.t -> ('a, 'e) T2(M).t
val run : ('a, 'e) T2(M).t -> ('a, 'e) T2(M).e
val void :
('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t List.t ->
(Monoid.Unit.t, 'e) T2(M).t
val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
module Fn :
sig
val id : 'a -> ('a, 'e) T2(M).t
val ignore :
('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
val nothing :
Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
val non :
('a -> (bool, 'e) T2(M).t) ->
'a -> (bool, 'e) T2(M).t
val apply_n_times :
n:Monoid.Int.t ->
('a -> ('a, 'e) T2(M).t) ->
'a -> ('a, 'e) T2(M).t
val compose :
('b -> ('c, 'e) T2(M).t) ->
('a -> ('b, 'e) T2(M).t) ->
'a -> ('c, 'e) T2(M).t
end
module Pair :
sig
val fst :
('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
val snd :
('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
end
module Triple :
sig
val fst :
('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
val snd :
('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
val trd :
('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
end
module Lift :
sig
val nullary : 'a -> ('a, 'e) T2(M).t
val unary :
('a -> 'b) ->
('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
val binary :
('a -> 'b -> 'c) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
val ternary :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t ->
('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t -> ('e, 's) T2(M).t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t ->
('e, 's) T2(M).t -> ('f, 's) T2(M).t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t ->
(Monoid.Unit.t, 's) T2(M).t) ->
f:(Monoid.Unit.t -> ('a, 's) T2(M).t) ->
catch:(exn -> ('a, 's) T2(M).t) ->
('a, 's) T2(M).t
end
module Collection :
sig
module type S =
sig
type 'a t
val all :
('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b t, 'e) T2(M).t
val iter :
'a t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val for_all :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val count :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t ->
f:('b -> ('a, 'e) T2(M).t) ->
('a, 'e) T2(M).t
val find :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a t, 'e) T2(M).t
val filter_map :
'a t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b t, 'e) T2(M).t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all :
('a, 'e) T2(M).t T.t ->
('a T.t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a T.t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val count :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> ('a, 'e) T2(M).t) ->
('a, 'e) T2(M).t
val find :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a T.t, 'e) T2(M).t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all :
('a, 'e) T2(M).t T.t ->
('a T.t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a T.t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val count :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> ('a, 'e) T2(M).t) ->
('a, 'e) T2(M).t
val find :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a T.t, 'e) T2(M).t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
end
end
module List :
sig
val all :
('a, 'e) T2(M).t List.t ->
('a List.t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t List.t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t List.t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a List.t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b List.t, 'e) T2(M).t
val iter :
'a List.t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a List.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a List.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a List.t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a List.t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a List.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val for_all :
'a List.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val count :
'a List.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b List.t ->
f:('b -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
val find :
'a List.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a List.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a List.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a List.t, 'e) T2(M).t
val filter_map :
'a List.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b List.t, 'e) T2(M).t
end
module Seq :
sig
val all :
('a, 'e) T2(M).t Seq.t ->
('a Seq.t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t Seq.t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t Seq.t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a Seq.t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b Seq.t, 'e) T2(M).t
val iter :
'a Seq.t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a Seq.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a Seq.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a Seq.t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a Seq.t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a Seq.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val for_all :
'a Seq.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val count :
'a Seq.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Seq.t ->
f:('b -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
val find :
'a Seq.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a Seq.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a Seq.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Seq.t, 'e) T2(M).t
val filter_map :
'a Seq.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Seq.t, 'e) T2(M).t
end
val ( >=> ) :
('a -> ('b, 'e) T2(M).t) ->
('b -> ('c, 'e) T2(M).t) -> 'a -> ('c, 'e) T2(M).t
val ( !! ) : 'a -> ('a, 'e) T2(M).t
val ( !$ ) :
('a -> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t ->
('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t -> ('e, 's) T2(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t ->
('e, 's) T2(M).t -> ('f, 's) T2(M).t
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) T2(M).t
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t ->
('a -> 'b) -> ('b, 'e) T2(M).t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) T2(M).t
val bind :
('a, 'e) T2(M).t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val map :
('a, 'e) T2(M).t ->
f:('a -> 'b) -> ('b, 'e) T2(M).t
val both :
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t ->
('a -> 'b) -> ('b, 'e) T2(M).t
end
val bind :
('a, 'e) T2(M).t ->
f:('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val return : 'a -> ('a, 'b) T2(M).t
val map :
('a, 'e) T2(M).t ->
f:('a -> 'b) -> ('b, 'e) T2(M).t
val join :
(('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
val ignore_m :
('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
val all :
('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
val all_ignore :
(Monoid.Unit.t, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
module Syntax :
sig
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t ->
('a -> 'b) -> ('b, 'e) T2(M).t
val ( >=> ) :
('a -> ('b, 'e) T2(M).t) ->
('b -> ('c, 'e) T2(M).t) ->
'a -> ('c, 'e) T2(M).t
val ( !! ) : 'a -> ('a, 'e) T2(M).t
val ( !$ ) :
('a -> 'b) ->
('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t ->
('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t -> ('e, 's) T2(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t ->
('e, 's) T2(M).t -> ('f, 's) T2(M).t
end
val put : 's -> (Monoid.Unit.t, 's) T2(M).t
val get : Monoid.Unit.t -> ('s, 's) T2(M).t
val gets : ('s -> 'r) -> ('r, 's) T2(M).t
val update :
('s -> 's) -> (Monoid.Unit.t, 's) T2(M).t
end
end
type ('a, 'e) t = (('a, 'e) storage, 'e) state
type 'a m = 'a
type ('a, 'e) e = 'e -> 'a * 'e
val lift : 'a -> ('a, 'e) t
val run : ('a, 'e) t -> ('a, 'e) e
val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
val forever : ('a, 'e) t -> ('b, 'e) t
module Fn :
sig
val id : 'a -> ('a, 'e) t
val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
val non : ('a -> (bool, 'e) t) -> 'a -> (bool, 'e) t
val apply_n_times :
n:Monoid.Int.t -> ('a -> ('a, 'e) t) -> 'a -> ('a, 'e) t
val compose :
('b -> ('c, 'e) t) ->
('a -> ('b, 'e) t) -> 'a -> ('c, 'e) t
end
module Pair :
sig
val fst : ('a * 'b, 'e) t -> ('a, 'e) t
val snd : ('a * 'b, 'e) t -> ('b, 'e) t
end
module Triple :
sig
val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
end
module Lift :
sig
val nullary : 'a -> ('a, 'e) t
val unary : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val binary :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ternary :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
f:(Monoid.Unit.t -> ('a, 's) t) ->
catch:(exn -> ('a, 's) t) -> ('a, 's) t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : ('a, 'e) t t -> ('a t, 'e) t
val all_ignore : ('a, 'e) t t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
val map : 'a t -> f:('a -> ('b, 'e) t) -> ('b t, 'e) t
val iter :
'a t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a t -> f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a t ->
f:('a -> ('b Option.t, 'e) t) -> ('b Option.t, 'e) t
val filter :
'a t -> f:('a -> (bool, 'e) t) -> ('a t, 'e) t
val filter_map :
'a t -> f:('a -> ('b Option.t, 'e) t) -> ('b t, 'e) t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : ('a, 'e) t T.t -> ('a T.t, 'e) t
val all_ignore :
('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val map :
'a T.t -> f:('a -> ('b, 'e) t) -> ('b T.t, 'e) t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a T.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a T.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a T.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a T.t -> f:('a -> (bool, 'e) t) -> ('a T.t, 'e) t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b T.t, 'e) t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : ('a, 'e) t T.t -> ('a T.t, 'e) t
val all_ignore :
('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val map :
'a T.t -> f:('a -> ('b, 'e) t) -> ('b T.t, 'e) t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a T.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a T.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a T.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a T.t -> f:('a -> (bool, 'e) t) -> ('a T.t, 'e) t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b T.t, 'e) t
end
end
module List :
sig
val all : ('a, 'e) t List.t -> ('a List.t, 'e) t
val all_ignore : ('a, 'e) t List.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
val map :
'a List.t -> f:('a -> ('b, 'e) t) -> ('b List.t, 'e) t
val iter :
'a List.t ->
f:('a -> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
val fold :
'a List.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a List.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a List.t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a List.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a List.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a List.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a List.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b List.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a List.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a List.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b Option.t, 'e) t
val filter :
'a List.t -> f:('a -> (bool, 'e) t) -> ('a List.t, 'e) t
val filter_map :
'a List.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b List.t, 'e) t
end
module Seq :
sig
val all : ('a, 'e) t Seq.t -> ('a Seq.t, 'e) t
val all_ignore : ('a, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
val map :
'a Seq.t -> f:('a -> ('b, 'e) t) -> ('b Seq.t, 'e) t
val iter :
'a Seq.t ->
f:('a -> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
val fold :
'a Seq.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a Seq.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a Seq.t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a Seq.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a Seq.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a Seq.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a Seq.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Seq.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a Seq.t -> f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a Seq.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b Option.t, 'e) t
val filter :
'a Seq.t -> f:('a -> (bool, 'e) t) -> ('a Seq.t, 'e) t
val filter_map :
'a Seq.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b Seq.t, 'e) t
end
val ( >=> ) :
('a -> ('b, 'e) t) -> ('b -> ('c, 'e) t) -> 'a -> ('c, 'e) t
val ( !! ) : 'a -> ('a, 'e) t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val ( !$$ ) :
('a -> 'b -> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
val ( >>= ) : ('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val bind :
('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
end
val bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val return : 'a -> ('a, 'b) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore :
(Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
module Syntax :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
val ( >=> ) :
('a -> ('b, 'e) t) ->
('b -> ('c, 'e) t) -> 'a -> ('c, 'e) t
val ( !! ) : 'a -> ('a, 'e) t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
end
val put : 's -> (Monoid.Unit.t, 's) t
val get : Monoid.Unit.t -> ('s, 's) t
val gets : ('s -> 'r) -> ('r, 's) t
val update : ('s -> 's) -> (Monoid.Unit.t, 's) t
val eval : ('a, 'e) t -> 'e -> 'a
val exec : ('a, 'e) t -> 'e -> 'e
module T1 :
functor (T : Core_kernel.Std.T) (M : Monad) ->
sig
type env = T.t
type 'a m = 'a M.t
type 'a t =
(('a, Monads.Std.Monad.State.T1.env)
Monads.Std.Monad.State.storage
Monads.Std.Monad.State.T1.m,
Monads.Std.Monad.State.T1.env)
Monads.Std.Monad.State.state
type 'a e =
Monads.Std.Monad.State.T1.env ->
('a * Monads.Std.Monad.State.T1.env)
Monads.Std.Monad.State.T1.m
end
module T2 :
functor (M : Monad) ->
sig
type 'a m = 'a M.t
type ('a, 'e) t =
(('a, 'e) Monads.Std.Monad.State.storage
Monads.Std.Monad.State.T2.m, 'e)
Monads.Std.Monad.State.state
type ('a, 'e) e =
'e -> ('a * 'e) Monads.Std.Monad.State.T2.m
end
module Make :
functor (T : Core_kernel.Std.T) (M : Monad) ->
sig
val lift : 'a M.t -> 'a T1(T)(M).t
val run : 'a T1(T)(M).t -> 'a T1(T)(M).e
val void : 'a T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t list ->
Monoid.Unit.t T1(T)(M).t
val forever : 'a T1(T)(M).t -> 'b T1(T)(M).t
module Fn :
sig
val id : 'a -> 'a T1(T)(M).t
val ignore :
'a T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
val nothing :
Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t
val non :
('a -> bool T1(T)(M).t) -> 'a -> bool T1(T)(M).t
val apply_n_times :
n:Monoid.Int.t ->
('a -> 'a T1(T)(M).t) -> 'a -> 'a T1(T)(M).t
val compose :
('b -> 'c T1(T)(M).t) ->
('a -> 'b T1(T)(M).t) -> 'a -> 'c T1(T)(M).t
end
module Pair :
sig
val fst : ('a * 'b) T1(T)(M).t -> 'a T1(T)(M).t
val snd : ('a * 'b) T1(T)(M).t -> 'b T1(T)(M).t
end
module Triple :
sig
val fst : ('a * 'b * 'c) T1(T)(M).t -> 'a T1(T)(M).t
val snd : ('a * 'b * 'c) T1(T)(M).t -> 'b T1(T)(M).t
val trd : ('a * 'b * 'c) T1(T)(M).t -> 'c T1(T)(M).t
end
module Lift :
sig
val nullary : 'a -> 'a T1(T)(M).t
val unary :
('a -> 'b) -> 'a T1(T)(M).t -> 'b T1(T)(M).t
val binary :
('a -> 'b -> 'c) ->
'a T1(T)(M).t -> 'b T1(T)(M).t -> 'c T1(T)(M).t
val ternary :
('a -> 'b -> 'c -> 'd) ->
'a T1(T)(M).t ->
'b T1(T)(M).t -> 'c T1(T)(M).t -> 'd T1(T)(M).t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t -> 'd T1(T)(M).t -> 'e T1(T)(M).t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t ->
'd T1(T)(M).t -> 'e T1(T)(M).t -> 'f T1(T)(M).t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t) ->
f:(Monoid.Unit.t -> 'a T1(T)(M).t) ->
catch:(exn -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a T1(T)(M).t t -> 'a t T1(T)(M).t
val all_ignore :
'a T1(T)(M).t t -> Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t t ->
Monoid.Unit.t T1(T)(M).t
val map :
'a t ->
f:('a -> 'b T1(T)(M).t) -> 'b t T1(T)(M).t
val iter :
'a t ->
f:('a -> Monoid.Unit.t T1(T)(M).t) ->
Monoid.Unit.t T1(T)(M).t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_right :
'a t ->
f:('a -> 'b -> 'b T1(T)(M).t) ->
init:'b -> 'b T1(T)(M).t
val reduce :
'a t ->
f:('a -> 'a -> 'a T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val exists :
'a t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val for_all :
'a t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val count :
'a t ->
f:('a -> bool T1(T)(M).t) ->
Monoid.Int.t T1(T)(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t ->
f:('b -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
val find :
'a t ->
f:('a -> bool T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val find_map :
'a t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Option.t T1(T)(M).t
val filter :
'a t ->
f:('a -> bool T1(T)(M).t) -> 'a t T1(T)(M).t
val filter_map :
'a t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b t T1(T)(M).t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all :
'a T1(T)(M).t T.t -> 'a T.t T1(T)(M).t
val all_ignore :
'a T1(T)(M).t T.t -> Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t T.t ->
Monoid.Unit.t T1(T)(M).t
val map :
'a T.t ->
f:('a -> 'b T1(T)(M).t) -> 'b T.t T1(T)(M).t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t T1(T)(M).t) ->
Monoid.Unit.t T1(T)(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) ->
'b T1(T)(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) ->
'b T1(T)(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b T1(T)(M).t) ->
init:'b -> 'b T1(T)(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> 'a T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val exists :
'a T.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val for_all :
'a T.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val count :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
Monoid.Int.t T1(T)(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
val find :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val find_map :
'a T.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Option.t T1(T)(M).t
val filter :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
'a T.t T1(T)(M).t
val filter_map :
'a T.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b T.t T1(T)(M).t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all :
'a T1(T)(M).t T.t -> 'a T.t T1(T)(M).t
val all_ignore :
'a T1(T)(M).t T.t -> Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t T.t ->
Monoid.Unit.t T1(T)(M).t
val map :
'a T.t ->
f:('a -> 'b T1(T)(M).t) -> 'b T.t T1(T)(M).t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t T1(T)(M).t) ->
Monoid.Unit.t T1(T)(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) ->
'b T1(T)(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) ->
'b T1(T)(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b T1(T)(M).t) ->
init:'b -> 'b T1(T)(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> 'a T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val exists :
'a T.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val for_all :
'a T.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val count :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
Monoid.Int.t T1(T)(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
val find :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val find_map :
'a T.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Option.t T1(T)(M).t
val filter :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
'a T.t T1(T)(M).t
val filter_map :
'a T.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b T.t T1(T)(M).t
end
end
module List :
sig
val all : 'a T1(T)(M).t list -> 'a list T1(T)(M).t
val all_ignore :
'a T1(T)(M).t list -> Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t list ->
Monoid.Unit.t T1(T)(M).t
val map :
'a list ->
f:('a -> 'b T1(T)(M).t) -> 'b list T1(T)(M).t
val iter :
'a list ->
f:('a -> Monoid.Unit.t T1(T)(M).t) ->
Monoid.Unit.t T1(T)(M).t
val fold :
'a list ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_left :
'a list ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_right :
'a list ->
f:('a -> 'b -> 'b T1(T)(M).t) ->
init:'b -> 'b T1(T)(M).t
val reduce :
'a list ->
f:('a -> 'a -> 'a T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val exists :
'a list ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val for_all :
'a list ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val count :
'a list ->
f:('a -> bool T1(T)(M).t) ->
Monoid.Int.t T1(T)(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list -> f:('b -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
val find :
'a list ->
f:('a -> bool T1(T)(M).t) -> 'a Option.t T1(T)(M).t
val find_map :
'a list ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Option.t T1(T)(M).t
val filter :
'a list ->
f:('a -> bool T1(T)(M).t) -> 'a list T1(T)(M).t
val filter_map :
'a list ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b list T1(T)(M).t
end
module Seq :
sig
val all :
'a T1(T)(M).t Core_kernel.Std.Sequence.t ->
'a Core_kernel.Std.Sequence.t T1(T)(M).t
val all_ignore :
'a T1(T)(M).t Core_kernel.Std.Sequence.t ->
Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t Core_kernel.Std.Sequence.t ->
Monoid.Unit.t T1(T)(M).t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b T1(T)(M).t) ->
'b Core_kernel.Std.Sequence.t T1(T)(M).t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> Monoid.Unit.t T1(T)(M).t) ->
Monoid.Unit.t T1(T)(M).t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> 'b T1(T)(M).t) ->
init:'b -> 'b T1(T)(M).t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> 'a T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(T)(M).t) ->
Monoid.Int.t T1(T)(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(T)(M).t) -> 'a Option.t T1(T)(M).t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Option.t T1(T)(M).t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(T)(M).t) ->
'a Core_kernel.Std.Sequence.t T1(T)(M).t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Core_kernel.Std.Sequence.t T1(T)(M).t
end
val ( >=> ) :
('a -> 'b T1(T)(M).t) ->
('b -> 'c T1(T)(M).t) -> 'a -> 'c T1(T)(M).t
val ( !! ) : 'a -> 'a T1(T)(M).t
val ( !$ ) : ('a -> 'b) -> 'a T1(T)(M).t -> 'b T1(T)(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
'a T1(T)(M).t -> 'b T1(T)(M).t -> 'c T1(T)(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a T1(T)(M).t ->
'b T1(T)(M).t -> 'c T1(T)(M).t -> 'd T1(T)(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t -> 'd T1(T)(M).t -> 'e T1(T)(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t ->
'd T1(T)(M).t -> 'e T1(T)(M).t -> 'f T1(T)(M).t
val ( >>= ) :
'a T1(T)(M).t -> ('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val ( >>| ) :
'a T1(T)(M).t -> ('a -> 'b) -> 'b T1(T)(M).t
module Monad_infix :
sig
val ( >>= ) :
'a T1(T)(M).t ->
('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val ( >>| ) :
'a T1(T)(M).t -> ('a -> 'b) -> 'b T1(T)(M).t
end
val bind :
'a T1(T)(M).t ->
f:('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val return : 'a -> 'a T1(T)(M).t
val map : 'a T1(T)(M).t -> f:('a -> 'b) -> 'b T1(T)(M).t
val join : 'a T1(T)(M).t T1(T)(M).t -> 'a T1(T)(M).t
val ignore_m : 'a T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
val all : 'a T1(T)(M).t list -> 'a list T1(T)(M).t
val all_ignore :
Monoid.Unit.t T1(T)(M).t list ->
Monoid.Unit.t T1(T)(M).t
module Let_syntax :
sig
val return : 'a -> 'a T1(T)(M).t
val ( >>= ) :
'a T1(T)(M).t ->
('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val ( >>| ) :
'a T1(T)(M).t -> ('a -> 'b) -> 'b T1(T)(M).t
module Let_syntax :
sig
val return : 'a -> 'a T1(T)(M).t
val bind :
'a T1(T)(M).t ->
f:('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val map :
'a T1(T)(M).t -> f:('a -> 'b) -> 'b T1(T)(M).t
val both :
'a T1(T)(M).t ->
'b T1(T)(M).t -> ('a * 'b) T1(T)(M).t
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) :
'a T1(T)(M).t ->
('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val ( >>| ) :
'a T1(T)(M).t -> ('a -> 'b) -> 'b T1(T)(M).t
val ( >=> ) :
('a -> 'b T1(T)(M).t) ->
('b -> 'c T1(T)(M).t) -> 'a -> 'c T1(T)(M).t
val ( !! ) : 'a -> 'a T1(T)(M).t
val ( !$ ) :
('a -> 'b) -> 'a T1(T)(M).t -> 'b T1(T)(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
'a T1(T)(M).t -> 'b T1(T)(M).t -> 'c T1(T)(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a T1(T)(M).t ->
'b T1(T)(M).t -> 'c T1(T)(M).t -> 'd T1(T)(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t -> 'd T1(T)(M).t -> 'e T1(T)(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t ->
'd T1(T)(M).t -> 'e T1(T)(M).t -> 'f T1(T)(M).t
end
val put : T.t -> Monoid.Unit.t T1(T)(M).t
val get : Monoid.Unit.t -> T.t T1(T)(M).t
val gets : (T.t -> 'r) -> 'r T1(T)(M).t
val update : (T.t -> T.t) -> Monoid.Unit.t T1(T)(M).t
end
module Make2 :
functor (M : Monad) ->
sig
val lift : 'a M.t -> ('a, 'e) T2(M).t
val run : ('a, 'e) T2(M).t -> ('a, 'e) T2(M).e
val void :
('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
module Fn :
sig
val id : 'a -> ('a, 'e) T2(M).t
val ignore :
('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
val nothing :
Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
val non :
('a -> (bool, 'e) T2(M).t) ->
'a -> (bool, 'e) T2(M).t
val apply_n_times :
n:Monoid.Int.t ->
('a -> ('a, 'e) T2(M).t) -> 'a -> ('a, 'e) T2(M).t
val compose :
('b -> ('c, 'e) T2(M).t) ->
('a -> ('b, 'e) T2(M).t) -> 'a -> ('c, 'e) T2(M).t
end
module Pair :
sig
val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
end
module Triple :
sig
val fst :
('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
val snd :
('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
val trd :
('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
end
module Lift :
sig
val nullary : 'a -> ('a, 'e) T2(M).t
val unary :
('a -> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
val binary :
('a -> 'b -> 'c) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
val ternary :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t ->
('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t -> ('e, 's) T2(M).t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t ->
('e, 's) T2(M).t -> ('f, 's) T2(M).t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t ->
(Monoid.Unit.t, 's) T2(M).t) ->
f:(Monoid.Unit.t -> ('a, 's) T2(M).t) ->
catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
end
module Collection :
sig
module type S =
sig
type 'a t
val all :
('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b t, 'e) T2(M).t
val iter :
'a t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val for_all :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val count :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t ->
f:('b -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
val find :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a t, 'e) T2(M).t
val filter_map :
'a t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b t, 'e) T2(M).t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all :
('a, 'e) T2(M).t T.t -> ('a T.t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a T.t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val count :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> ('a, 'e) T2(M).t) ->
('a, 'e) T2(M).t
val find :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a T.t, 'e) T2(M).t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all :
('a, 'e) T2(M).t T.t -> ('a T.t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a T.t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val count :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> ('a, 'e) T2(M).t) ->
('a, 'e) T2(M).t
val find :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a T.t, 'e) T2(M).t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
end
end
module List :
sig
val all :
('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a list ->
f:('a -> ('b, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
val iter :
'a list ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a list ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a list ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a list ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a list ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a list ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val for_all :
'a list ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val count :
'a list ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list ->
f:('b -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
val find :
'a list ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a list ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a list ->
f:('a -> (bool, 'e) T2(M).t) ->
('a list, 'e) T2(M).t
val filter_map :
'a list ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b list, 'e) T2(M).t
end
module Seq :
sig
val all :
('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
('a Core_kernel.Std.Sequence.t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t
Core_kernel.Std.Sequence.t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b Core_kernel.Std.Sequence.t, 'e) T2(M).t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Core_kernel.Std.Sequence.t, 'e) T2(M).t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Core_kernel.Std.Sequence.t, 'e) T2(M).t
end
val ( >=> ) :
('a -> ('b, 'e) T2(M).t) ->
('b -> ('c, 'e) T2(M).t) -> 'a -> ('c, 'e) T2(M).t
val ( !! ) : 'a -> ('a, 'e) T2(M).t
val ( !$ ) :
('a -> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t ->
('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t -> ('e, 's) T2(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t ->
('e, 's) T2(M).t -> ('f, 's) T2(M).t
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) T2(M).t
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) T2(M).t
val bind :
('a, 'e) T2(M).t ->
f:('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val map :
('a, 'e) T2(M).t ->
f:('a -> 'b) -> ('b, 'e) T2(M).t
val both :
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
end
val bind :
('a, 'e) T2(M).t ->
f:('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val return : 'a -> ('a, 'b) T2(M).t
val map :
('a, 'e) T2(M).t -> f:('a -> 'b) -> ('b, 'e) T2(M).t
val join :
(('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
val ignore_m :
('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
val all_ignore :
(Monoid.Unit.t, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
module Syntax :
sig
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
val ( >=> ) :
('a -> ('b, 'e) T2(M).t) ->
('b -> ('c, 'e) T2(M).t) -> 'a -> ('c, 'e) T2(M).t
val ( !! ) : 'a -> ('a, 'e) T2(M).t
val ( !$ ) :
('a -> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t ->
('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t -> ('e, 's) T2(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t ->
('e, 's) T2(M).t -> ('f, 's) T2(M).t
end
val put : 's -> (Monoid.Unit.t, 's) T2(M).t
val get : Monoid.Unit.t -> ('s, 's) T2(M).t
val gets : ('s -> 'r) -> ('r, 's) T2(M).t
val update : ('s -> 's) -> (Monoid.Unit.t, 's) T2(M).t
end
end
module Fun :
sig
module type S =
sig
type 'a t
type 'a m
type 'a e
val lift : 'a m -> 'a t
val run : 'a t -> 'a e
val void : 'a t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
val forever : 'a t -> 'b t
module Fn :
sig
val id : 'a -> 'a t
val ignore : 'a t -> Monoid.Unit.t t
val nothing : Monoid.Unit.t -> Monoid.Unit.t t
val non : ('a -> bool t) -> 'a -> bool t
val apply_n_times :
n:Monoid.Int.t -> ('a -> 'a t) -> 'a -> 'a t
val compose :
('b -> 'c t) -> ('a -> 'b t) -> 'a -> 'c t
end
module Pair :
sig
val fst : ('a * 'b) t -> 'a t
val snd : ('a * 'b) t -> 'b t
end
module Triple :
sig
val fst : ('a * 'b * 'c) t -> 'a t
val snd : ('a * 'b * 'c) t -> 'b t
val trd : ('a * 'b * 'c) t -> 'c t
end
module Lift :
sig
val nullary : 'a -> 'a t
val unary : ('a -> 'b) -> 'a t -> 'b t
val binary : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ternary :
('a -> 'b -> 'c -> 'd) ->
'a t -> 'b t -> 'c t -> 'd t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
f:(Monoid.Unit.t -> 'a t) ->
catch:(exn -> 'a t) -> 'a t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a t t -> 'a t t
val all_ignore : 'a t t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
val map : 'a t -> f:('a -> 'b t) -> 'b t t
val iter :
'a t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a t -> f:('a -> bool t) -> bool t
val for_all : 'a t -> f:('a -> bool t) -> bool t
val count :
'a t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> 'a t) -> 'a t
val find :
'a t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a t -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter : 'a t -> f:('a -> bool t) -> 'a t t
val filter_map :
'a t -> f:('a -> 'b Option.t t) -> 'b t t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a T.t -> f:('a -> bool t) -> bool t
val for_all :
'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a T.t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t -> f:('a -> 'b Option.t t) -> 'b T.t t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a T.t -> f:('a -> bool t) -> bool t
val for_all :
'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a T.t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t -> f:('a -> 'b Option.t t) -> 'b T.t t
end
end
module List :
sig
val all : 'a t List.t -> 'a List.t t
val all_ignore : 'a t List.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t List.t -> Monoid.Unit.t t
val map : 'a List.t -> f:('a -> 'b t) -> 'b List.t t
val iter :
'a List.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a List.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a List.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a List.t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a List.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a List.t -> f:('a -> bool t) -> bool t
val for_all : 'a List.t -> f:('a -> bool t) -> bool t
val count :
'a List.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b List.t -> f:('b -> 'a t) -> 'a t
val find :
'a List.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a List.t -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a List.t -> f:('a -> bool t) -> 'a List.t t
val filter_map :
'a List.t -> f:('a -> 'b Option.t t) -> 'b List.t t
end
module Seq :
sig
val all : 'a t Seq.t -> 'a Seq.t t
val all_ignore : 'a t Seq.t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t Seq.t -> Monoid.Unit.t t
val map : 'a Seq.t -> f:('a -> 'b t) -> 'b Seq.t t
val iter :
'a Seq.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a Seq.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a Seq.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a Seq.t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a Seq.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a Seq.t -> f:('a -> bool t) -> bool t
val for_all : 'a Seq.t -> f:('a -> bool t) -> bool t
val count :
'a Seq.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Seq.t -> f:('b -> 'a t) -> 'a t
val find :
'a Seq.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a Seq.t -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter : 'a Seq.t -> f:('a -> bool t) -> 'a Seq.t t
val filter_map :
'a Seq.t -> f:('a -> 'b Option.t t) -> 'b Seq.t t
end
val ( >=> ) : ('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Monad_infix :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
end
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val return : 'a -> 'a t
val map : 'a t -> f:('a -> 'b) -> 'b t
val join : 'a t t -> 'a t
val ignore_m : 'a t -> Monoid.Unit.t t
val all : 'a t list -> 'a list t
val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
module Let_syntax :
sig
val return : 'a -> 'a t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Let_syntax :
sig
val return : 'a -> 'a t
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val map : 'a t -> f:('a -> 'b) -> 'b t
val both : 'a t -> 'b t -> ('a * 'b) t
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
val ( >=> ) :
('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
end
module type S2 =
sig
type ('a, 'e) t
type ('a, 'e) m
type ('a, 'e) e
val lift : ('a, 'e) m -> ('a, 'e) t
val run : ('a, 'e) t -> ('a, 'e) e
val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
val forever : ('a, 'e) t -> ('b, 'e) t
module Fn :
sig
val id : 'a -> ('a, 'e) t
val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
val non : ('a -> (bool, 'e) t) -> 'a -> (bool, 'e) t
val apply_n_times :
n:Monoid.Int.t ->
('a -> ('a, 'e) t) -> 'a -> ('a, 'e) t
val compose :
('b -> ('c, 'e) t) ->
('a -> ('b, 'e) t) -> 'a -> ('c, 'e) t
end
module Pair :
sig
val fst : ('a * 'b, 'e) t -> ('a, 'e) t
val snd : ('a * 'b, 'e) t -> ('b, 'e) t
end
module Triple :
sig
val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
end
module Lift :
sig
val nullary : 'a -> ('a, 'e) t
val unary : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val binary :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ternary :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
f:(Monoid.Unit.t -> ('a, 's) t) ->
catch:(exn -> ('a, 's) t) -> ('a, 's) t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : ('a, 'e) t t -> ('a t, 'e) t
val all_ignore :
('a, 'e) t t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
val map :
'a t -> f:('a -> ('b, 'e) t) -> ('b t, 'e) t
val iter :
'a t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a t -> f:('a -> (bool, 'e) t) -> ('a t, 'e) t
val filter_map :
'a t ->
f:('a -> ('b Option.t, 'e) t) -> ('b t, 'e) t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : ('a, 'e) t T.t -> ('a T.t, 'e) t
val all_ignore :
('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t T.t ->
(Monoid.Unit.t, 'e) t
val map :
'a T.t ->
f:('a -> ('b, 'e) t) -> ('b T.t, 'e) t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) t) ->
('a Option.t, 'e) t
val exists :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a T.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a T.t, 'e) t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b T.t, 'e) t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : ('a, 'e) t T.t -> ('a T.t, 'e) t
val all_ignore :
('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t T.t ->
(Monoid.Unit.t, 'e) t
val map :
'a T.t ->
f:('a -> ('b, 'e) t) -> ('b T.t, 'e) t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) t) ->
('a Option.t, 'e) t
val exists :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a T.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a T.t, 'e) t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b T.t, 'e) t
end
end
module List :
sig
val all : ('a, 'e) t List.t -> ('a List.t, 'e) t
val all_ignore :
('a, 'e) t List.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
val map :
'a List.t ->
f:('a -> ('b, 'e) t) -> ('b List.t, 'e) t
val iter :
'a List.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a List.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a List.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a List.t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a List.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a List.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a List.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a List.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b List.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a List.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a List.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b Option.t, 'e) t
val filter :
'a List.t ->
f:('a -> (bool, 'e) t) -> ('a List.t, 'e) t
val filter_map :
'a List.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b List.t, 'e) t
end
module Seq :
sig
val all : ('a, 'e) t Seq.t -> ('a Seq.t, 'e) t
val all_ignore :
('a, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
val map :
'a Seq.t -> f:('a -> ('b, 'e) t) -> ('b Seq.t, 'e) t
val iter :
'a Seq.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a Seq.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a Seq.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a Seq.t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a Seq.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a Seq.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a Seq.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a Seq.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Seq.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a Seq.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a Seq.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b Option.t, 'e) t
val filter :
'a Seq.t ->
f:('a -> (bool, 'e) t) -> ('a Seq.t, 'e) t
val filter_map :
'a Seq.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b Seq.t, 'e) t
end
val ( >=> ) :
('a -> ('b, 'e) t) ->
('b -> ('c, 'e) t) -> 'a -> ('c, 'e) t
val ( !! ) : 'a -> ('a, 'e) t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val bind :
('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val both :
('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
end
val bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val return : 'a -> ('a, 'b) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore :
(Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
module Syntax :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
val ( >=> ) :
('a -> ('b, 'e) t) ->
('b -> ('c, 'e) t) -> 'a -> ('c, 'e) t
val ( !! ) : 'a -> ('a, 'e) t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
end
end
type 'a thunk
type 'a t = 'a thunk
type 'a m = 'a
type 'a e = 'a
val lift : 'a -> 'a t
val run : 'a t -> 'a
val void : 'a t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
val forever : 'a t -> 'b t
module Fn :
sig
val id : 'a -> 'a t
val ignore : 'a t -> Monoid.Unit.t t
val nothing : Monoid.Unit.t -> Monoid.Unit.t t
val non : ('a -> bool t) -> 'a -> bool t
val apply_n_times :
n:Monoid.Int.t -> ('a -> 'a t) -> 'a -> 'a t
val compose : ('b -> 'c t) -> ('a -> 'b t) -> 'a -> 'c t
end
module Pair :
sig
val fst : ('a * 'b) t -> 'a t
val snd : ('a * 'b) t -> 'b t
end
module Triple :
sig
val fst : ('a * 'b * 'c) t -> 'a t
val snd : ('a * 'b * 'c) t -> 'b t
val trd : ('a * 'b * 'c) t -> 'c t
end
module Lift :
sig
val nullary : 'a -> 'a t
val unary : ('a -> 'b) -> 'a t -> 'b t
val binary : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ternary :
('a -> 'b -> 'c -> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
f:(Monoid.Unit.t -> 'a t) -> catch:(exn -> 'a t) -> 'a t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a thunk t -> 'a t thunk
val all_ignore : 'a thunk t -> Monoid.Unit.t thunk
val sequence :
Monoid.Unit.t thunk t -> Monoid.Unit.t thunk
val map : 'a t -> f:('a -> 'b thunk) -> 'b t thunk
val iter :
'a t ->
f:('a -> Monoid.Unit.t thunk) -> Monoid.Unit.t thunk
val fold :
'a t ->
init:'b -> f:('b -> 'a -> 'b thunk) -> 'b thunk
val fold_left :
'a t ->
init:'b -> f:('b -> 'a -> 'b thunk) -> 'b thunk
val fold_right :
'a t ->
f:('a -> 'b -> 'b thunk) -> init:'b -> 'b thunk
val reduce :
'a t -> f:('a -> 'a -> 'a thunk) -> 'a Option.t thunk
val exists : 'a t -> f:('a -> bool thunk) -> bool thunk
val for_all :
'a t -> f:('a -> bool thunk) -> bool thunk
val count :
'a t -> f:('a -> bool thunk) -> Monoid.Int.t thunk
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> 'a thunk) -> 'a thunk
val find :
'a t -> f:('a -> bool thunk) -> 'a Option.t thunk
val find_map :
'a t ->
f:('a -> 'b Option.t thunk) -> 'b Option.t thunk
val filter : 'a t -> f:('a -> bool thunk) -> 'a t thunk
val filter_map :
'a t -> f:('a -> 'b Option.t thunk) -> 'b t thunk
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a T.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a T.t -> f:('a -> bool t) -> bool t
val for_all : 'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a T.t -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter : 'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t -> f:('a -> 'b Option.t t) -> 'b T.t t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a T.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a T.t -> f:('a -> bool t) -> bool t
val for_all : 'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a T.t -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter : 'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t -> f:('a -> 'b Option.t t) -> 'b T.t t
end
end
module List :
sig
val all : 'a t List.t -> 'a List.t t
val all_ignore : 'a t List.t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
val map : 'a List.t -> f:('a -> 'b t) -> 'b List.t t
val iter :
'a List.t -> f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a List.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a List.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a List.t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a List.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a List.t -> f:('a -> bool t) -> bool t
val for_all : 'a List.t -> f:('a -> bool t) -> bool t
val count : 'a List.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b List.t -> f:('b -> 'a t) -> 'a t
val find : 'a List.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a List.t -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter : 'a List.t -> f:('a -> bool t) -> 'a List.t t
val filter_map :
'a List.t -> f:('a -> 'b Option.t t) -> 'b List.t t
end
module Seq :
sig
val all : 'a t Seq.t -> 'a Seq.t t
val all_ignore : 'a t Seq.t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t Seq.t -> Monoid.Unit.t t
val map : 'a Seq.t -> f:('a -> 'b t) -> 'b Seq.t t
val iter :
'a Seq.t -> f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a Seq.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a Seq.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a Seq.t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a Seq.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a Seq.t -> f:('a -> bool t) -> bool t
val for_all : 'a Seq.t -> f:('a -> bool t) -> bool t
val count : 'a Seq.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Seq.t -> f:('b -> 'a t) -> 'a t
val find : 'a Seq.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a Seq.t -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter : 'a Seq.t -> f:('a -> bool t) -> 'a Seq.t t
val filter_map :
'a Seq.t -> f:('a -> 'b Option.t t) -> 'b Seq.t t
end
val ( >=> ) : ('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Monad_infix :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
end
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val return : 'a -> 'a t
val map : 'a t -> f:('a -> 'b) -> 'b t
val join : 'a t t -> 'a t
val ignore_m : 'a t -> Monoid.Unit.t t
val all : 'a t list -> 'a list t
val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
module Let_syntax :
sig
val return : 'a -> 'a t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Let_syntax :
sig
val return : 'a -> 'a t
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val map : 'a t -> f:('a -> 'b) -> 'b t
val both : 'a t -> 'b t -> ('a * 'b) t
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
val ( >=> ) : ('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
module T1 :
functor (M : Monad) ->
sig
type 'a m = 'a M.t
type 'a t =
'a Monads.Std.Monad.Fun.T1.m
Monads.Std.Monad.Fun.thunk
type 'a e = 'a Monads.Std.Monad.Fun.T1.m
end
module Make :
functor (M : Monad) ->
sig
val lift : 'a M.t -> 'a T1(M).t
val run : 'a T1(M).t -> 'a Monads.Std.Monad.Fun.T1.m
val void : 'a T1(M).t -> Monoid.Unit.t T1(M).t
val sequence :
Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
val forever : 'a T1(M).t -> 'b T1(M).t
module Fn :
sig
val id : 'a -> 'a T1(M).t
val ignore : 'a T1(M).t -> Monoid.Unit.t T1(M).t
val nothing : Monoid.Unit.t -> Monoid.Unit.t T1(M).t
val non : ('a -> bool T1(M).t) -> 'a -> bool T1(M).t
val apply_n_times :
n:Monoid.Int.t ->
('a -> 'a T1(M).t) -> 'a -> 'a T1(M).t
val compose :
('b -> 'c T1(M).t) ->
('a -> 'b T1(M).t) -> 'a -> 'c T1(M).t
end
module Pair :
sig
val fst : ('a * 'b) T1(M).t -> 'a T1(M).t
val snd : ('a * 'b) T1(M).t -> 'b T1(M).t
end
module Triple :
sig
val fst : ('a * 'b * 'c) T1(M).t -> 'a T1(M).t
val snd : ('a * 'b * 'c) T1(M).t -> 'b T1(M).t
val trd : ('a * 'b * 'c) T1(M).t -> 'c T1(M).t
end
module Lift :
sig
val nullary : 'a -> 'a T1(M).t
val unary : ('a -> 'b) -> 'a T1(M).t -> 'b T1(M).t
val binary :
('a -> 'b -> 'c) ->
'a T1(M).t -> 'b T1(M).t -> 'c T1(M).t
val ternary :
('a -> 'b -> 'c -> 'd) ->
'a T1(M).t ->
'b T1(M).t -> 'c T1(M).t -> 'd T1(M).t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(M).t ->
'b T1(M).t ->
'c T1(M).t -> 'd T1(M).t -> 'e T1(M).t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(M).t ->
'b T1(M).t ->
'c T1(M).t ->
'd T1(M).t -> 'e T1(M).t -> 'f T1(M).t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t T1(M).t) ->
f:(Monoid.Unit.t -> 'a T1(M).t) ->
catch:(exn -> 'a T1(M).t) -> 'a T1(M).t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a T1(M).t t -> 'a t T1(M).t
val all_ignore :
'a T1(M).t t -> Monoid.Unit.t T1(M).t
val sequence :
Monoid.Unit.t T1(M).t t ->
Monoid.Unit.t T1(M).t
val map :
'a t -> f:('a -> 'b T1(M).t) -> 'b t T1(M).t
val iter :
'a t ->
f:('a -> Monoid.Unit.t T1(M).t) ->
Monoid.Unit.t T1(M).t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_right :
'a t ->
f:('a -> 'b -> 'b T1(M).t) ->
init:'b -> 'b T1(M).t
val reduce :
'a t ->
f:('a -> 'a -> 'a T1(M).t) ->
'a Option.t T1(M).t
val exists :
'a t -> f:('a -> bool T1(M).t) -> bool T1(M).t
val for_all :
'a t -> f:('a -> bool T1(M).t) -> bool T1(M).t
val count :
'a t ->
f:('a -> bool T1(M).t) -> Monoid.Int.t T1(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> 'a T1(M).t) -> 'a T1(M).t
val find :
'a t ->
f:('a -> bool T1(M).t) -> 'a Option.t T1(M).t
val find_map :
'a t ->
f:('a -> 'b Option.t T1(M).t) ->
'b Option.t T1(M).t
val filter :
'a t -> f:('a -> bool T1(M).t) -> 'a t T1(M).t
val filter_map :
'a t ->
f:('a -> 'b Option.t T1(M).t) -> 'b t T1(M).t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : 'a T1(M).t T.t -> 'a T.t T1(M).t
val all_ignore :
'a T1(M).t T.t -> Monoid.Unit.t T1(M).t
val sequence :
Monoid.Unit.t T1(M).t T.t ->
Monoid.Unit.t T1(M).t
val map :
'a T.t ->
f:('a -> 'b T1(M).t) -> 'b T.t T1(M).t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t T1(M).t) ->
Monoid.Unit.t T1(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b T1(M).t) ->
init:'b -> 'b T1(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> 'a T1(M).t) ->
'a Option.t T1(M).t
val exists :
'a T.t ->
f:('a -> bool T1(M).t) -> bool T1(M).t
val for_all :
'a T.t ->
f:('a -> bool T1(M).t) -> bool T1(M).t
val count :
'a T.t ->
f:('a -> bool T1(M).t) ->
Monoid.Int.t T1(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a T1(M).t) -> 'a T1(M).t
val find :
'a T.t ->
f:('a -> bool T1(M).t) -> 'a Option.t T1(M).t
val find_map :
'a T.t ->
f:('a -> 'b Option.t T1(M).t) ->
'b Option.t T1(M).t
val filter :
'a T.t ->
f:('a -> bool T1(M).t) -> 'a T.t T1(M).t
val filter_map :
'a T.t ->
f:('a -> 'b Option.t T1(M).t) ->
'b T.t T1(M).t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : 'a T1(M).t T.t -> 'a T.t T1(M).t
val all_ignore :
'a T1(M).t T.t -> Monoid.Unit.t T1(M).t
val sequence :
Monoid.Unit.t T1(M).t T.t ->
Monoid.Unit.t T1(M).t
val map :
'a T.t ->
f:('a -> 'b T1(M).t) -> 'b T.t T1(M).t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t T1(M).t) ->
Monoid.Unit.t T1(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b T1(M).t) ->
init:'b -> 'b T1(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> 'a T1(M).t) ->
'a Option.t T1(M).t
val exists :
'a T.t ->
f:('a -> bool T1(M).t) -> bool T1(M).t
val for_all :
'a T.t ->
f:('a -> bool T1(M).t) -> bool T1(M).t
val count :
'a T.t ->
f:('a -> bool T1(M).t) ->
Monoid.Int.t T1(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a T1(M).t) -> 'a T1(M).t
val find :
'a T.t ->
f:('a -> bool T1(M).t) -> 'a Option.t T1(M).t
val find_map :
'a T.t ->
f:('a -> 'b Option.t T1(M).t) ->
'b Option.t T1(M).t
val filter :
'a T.t ->
f:('a -> bool T1(M).t) -> 'a T.t T1(M).t
val filter_map :
'a T.t ->
f:('a -> 'b Option.t T1(M).t) ->
'b T.t T1(M).t
end
end
module List :
sig
val all : 'a T1(M).t list -> 'a list T1(M).t
val all_ignore :
'a T1(M).t list -> Monoid.Unit.t T1(M).t
val sequence :
Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
val map :
'a list -> f:('a -> 'b T1(M).t) -> 'b list T1(M).t
val iter :
'a list ->
f:('a -> Monoid.Unit.t T1(M).t) ->
Monoid.Unit.t T1(M).t
val fold :
'a list ->
init:'b -> f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_left :
'a list ->
init:'b -> f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_right :
'a list ->
f:('a -> 'b -> 'b T1(M).t) -> init:'b -> 'b T1(M).t
val reduce :
'a list ->
f:('a -> 'a -> 'a T1(M).t) -> 'a Option.t T1(M).t
val exists :
'a list -> f:('a -> bool T1(M).t) -> bool T1(M).t
val for_all :
'a list -> f:('a -> bool T1(M).t) -> bool T1(M).t
val count :
'a list ->
f:('a -> bool T1(M).t) -> Monoid.Int.t T1(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list -> f:('b -> 'a T1(M).t) -> 'a T1(M).t
val find :
'a list ->
f:('a -> bool T1(M).t) -> 'a Option.t T1(M).t
val find_map :
'a list ->
f:('a -> 'b Option.t T1(M).t) ->
'b Option.t T1(M).t
val filter :
'a list ->
f:('a -> bool T1(M).t) -> 'a list T1(M).t
val filter_map :
'a list ->
f:('a -> 'b Option.t T1(M).t) -> 'b list T1(M).t
end
module Seq :
sig
val all :
'a T1(M).t Core_kernel.Std.Sequence.t ->
'a Core_kernel.Std.Sequence.t T1(M).t
val all_ignore :
'a T1(M).t Core_kernel.Std.Sequence.t ->
Monoid.Unit.t T1(M).t
val sequence :
Monoid.Unit.t T1(M).t Core_kernel.Std.Sequence.t ->
Monoid.Unit.t T1(M).t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b T1(M).t) ->
'b Core_kernel.Std.Sequence.t T1(M).t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> Monoid.Unit.t T1(M).t) ->
Monoid.Unit.t T1(M).t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> 'b T1(M).t) -> init:'b -> 'b T1(M).t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> 'a T1(M).t) -> 'a Option.t T1(M).t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(M).t) -> bool T1(M).t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(M).t) -> bool T1(M).t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(M).t) -> Monoid.Int.t T1(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> 'a T1(M).t) -> 'a T1(M).t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(M).t) -> 'a Option.t T1(M).t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b Option.t T1(M).t) ->
'b Option.t T1(M).t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(M).t) ->
'a Core_kernel.Std.Sequence.t T1(M).t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b Option.t T1(M).t) ->
'b Core_kernel.Std.Sequence.t T1(M).t
end
val ( >=> ) :
('a -> 'b T1(M).t) ->
('b -> 'c T1(M).t) -> 'a -> 'c T1(M).t
val ( !! ) : 'a -> 'a T1(M).t
val ( !$ ) : ('a -> 'b) -> 'a T1(M).t -> 'b T1(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
'a T1(M).t -> 'b T1(M).t -> 'c T1(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a T1(M).t -> 'b T1(M).t -> 'c T1(M).t -> 'd T1(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(M).t ->
'b T1(M).t -> 'c T1(M).t -> 'd T1(M).t -> 'e T1(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(M).t ->
'b T1(M).t ->
'c T1(M).t -> 'd T1(M).t -> 'e T1(M).t -> 'f T1(M).t
val ( >>= ) :
'a T1(M).t -> ('a -> 'b T1(M).t) -> 'b T1(M).t
val ( >>| ) : 'a T1(M).t -> ('a -> 'b) -> 'b T1(M).t
module Monad_infix :
sig
val ( >>= ) :
'a T1(M).t -> ('a -> 'b T1(M).t) -> 'b T1(M).t
val ( >>| ) : 'a T1(M).t -> ('a -> 'b) -> 'b T1(M).t
end
val bind :
'a T1(M).t -> f:('a -> 'b T1(M).t) -> 'b T1(M).t
val return : 'a -> 'a T1(M).t
val map : 'a T1(M).t -> f:('a -> 'b) -> 'b T1(M).t
val join : 'a T1(M).t T1(M).t -> 'a T1(M).t
val ignore_m : 'a T1(M).t -> Monoid.Unit.t T1(M).t
val all : 'a T1(M).t list -> 'a list T1(M).t
val all_ignore :
Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
module Let_syntax :
sig
val return : 'a -> 'a T1(M).t
val ( >>= ) :
'a T1(M).t -> ('a -> 'b T1(M).t) -> 'b T1(M).t
val ( >>| ) : 'a T1(M).t -> ('a -> 'b) -> 'b T1(M).t
module Let_syntax :
sig
val return : 'a -> 'a T1(M).t
val bind :
'a T1(M).t ->
f:('a -> 'b T1(M).t) -> 'b T1(M).t
val map :
'a T1(M).t -> f:('a -> 'b) -> 'b T1(M).t
val both :
'a T1(M).t -> 'b T1(M).t -> ('a * 'b) T1(M).t
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) :
'a T1(M).t -> ('a -> 'b T1(M).t) -> 'b T1(M).t
val ( >>| ) : 'a T1(M).t -> ('a -> 'b) -> 'b T1(M).t
val ( >=> ) :
('a -> 'b T1(M).t) ->
('b -> 'c T1(M).t) -> 'a -> 'c T1(M).t
val ( !! ) : 'a -> 'a T1(M).t
val ( !$ ) : ('a -> 'b) -> 'a T1(M).t -> 'b T1(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
'a T1(M).t -> 'b T1(M).t -> 'c T1(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a T1(M).t ->
'b T1(M).t -> 'c T1(M).t -> 'd T1(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(M).t ->
'b T1(M).t ->
'c T1(M).t -> 'd T1(M).t -> 'e T1(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(M).t ->
'b T1(M).t ->
'c T1(M).t ->
'd T1(M).t -> 'e T1(M).t -> 'f T1(M).t
end
end
module T2 :
functor (M : Monad2) ->
sig
type ('a, 'e) m = ('a, 'e) M.t
type ('a, 'e) t =
('a, 'e) Monads.Std.Monad.Fun.T2.m
Monads.Std.Monad.Fun.thunk
type ('a, 'e) e = ('a, 'e) Monads.Std.Monad.Fun.T2.m
end
module Make2 :
functor (M : Monad2) ->
sig
val lift : ('a, 'e) M.t -> ('a, 'e) T2(M).t
val run :
('a, 'e) T2(M).t -> ('a, 'e) Monads.Std.Monad.Fun.T2.m
val void :
('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
module Fn :
sig
val id : 'a -> ('a, 'e) T2(M).t
val ignore :
('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
val nothing :
Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
val non :
('a -> (bool, 'e) T2(M).t) ->
'a -> (bool, 'e) T2(M).t
val apply_n_times :
n:Monoid.Int.t ->
('a -> ('a, 'e) T2(M).t) -> 'a -> ('a, 'e) T2(M).t
val compose :
('b -> ('c, 'e) T2(M).t) ->
('a -> ('b, 'e) T2(M).t) -> 'a -> ('c, 'e) T2(M).t
end
module Pair :
sig
val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
end
module Triple :
sig
val fst :
('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
val snd :
('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
val trd :
('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
end
module Lift :
sig
val nullary : 'a -> ('a, 'e) T2(M).t
val unary :
('a -> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
val binary :
('a -> 'b -> 'c) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
val ternary :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t ->
('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t -> ('e, 's) T2(M).t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t ->
('e, 's) T2(M).t -> ('f, 's) T2(M).t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t ->
(Monoid.Unit.t, 's) T2(M).t) ->
f:(Monoid.Unit.t -> ('a, 's) T2(M).t) ->
catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
end
module Collection :
sig
module type S =
sig
type 'a t
val all :
('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b t, 'e) T2(M).t
val iter :
'a t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val for_all :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val count :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t ->
f:('b -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
val find :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a t, 'e) T2(M).t
val filter_map :
'a t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b t, 'e) T2(M).t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all :
('a, 'e) T2(M).t T.t -> ('a T.t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a T.t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val count :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> ('a, 'e) T2(M).t) ->
('a, 'e) T2(M).t
val find :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a T.t, 'e) T2(M).t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all :
('a, 'e) T2(M).t T.t -> ('a T.t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a T.t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val count :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> ('a, 'e) T2(M).t) ->
('a, 'e) T2(M).t
val find :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a T.t, 'e) T2(M).t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
end
end
module List :
sig
val all :
('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a list ->
f:('a -> ('b, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
val iter :
'a list ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a list ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a list ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a list ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a list ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a list ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val for_all :
'a list ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val count :
'a list ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list ->
f:('b -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
val find :
'a list ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a list ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a list ->
f:('a -> (bool, 'e) T2(M).t) ->
('a list, 'e) T2(M).t
val filter_map :
'a list ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b list, 'e) T2(M).t
end
module Seq :
sig
val all :
('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
('a Core_kernel.Std.Sequence.t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t
Core_kernel.Std.Sequence.t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b Core_kernel.Std.Sequence.t, 'e) T2(M).t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Core_kernel.Std.Sequence.t, 'e) T2(M).t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Core_kernel.Std.Sequence.t, 'e) T2(M).t
end
val ( >=> ) :
('a -> ('b, 'e) T2(M).t) ->
('b -> ('c, 'e) T2(M).t) -> 'a -> ('c, 'e) T2(M).t
val ( !! ) : 'a -> ('a, 'e) T2(M).t
val ( !$ ) :
('a -> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t ->
('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t -> ('e, 's) T2(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t ->
('e, 's) T2(M).t -> ('f, 's) T2(M).t
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) T2(M).t
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) T2(M).t
val bind :
('a, 'e) T2(M).t ->
f:('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val map :
('a, 'e) T2(M).t ->
f:('a -> 'b) -> ('b, 'e) T2(M).t
val both :
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
end
val bind :
('a, 'e) T2(M).t ->
f:('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val return : 'a -> ('a, 'b) T2(M).t
val map :
('a, 'e) T2(M).t -> f:('a -> 'b) -> ('b, 'e) T2(M).t
val join :
(('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
val ignore_m :
('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
val all_ignore :
(Monoid.Unit.t, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
module Syntax :
sig
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
val ( >=> ) :
('a -> ('b, 'e) T2(M).t) ->
('b -> ('c, 'e) T2(M).t) -> 'a -> ('c, 'e) T2(M).t
val ( !! ) : 'a -> ('a, 'e) T2(M).t
val ( !$ ) :
('a -> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t ->
('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t -> ('e, 's) T2(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t ->
('e, 's) T2(M).t -> ('f, 's) T2(M).t
end
end
end
module Lazy :
sig
module type S =
sig
type 'a t
type 'a m
type 'a e
val lift : 'a m -> 'a t
val run : 'a t -> 'a e
val void : 'a t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
val forever : 'a t -> 'b t
module Fn :
sig
val id : 'a -> 'a t
val ignore : 'a t -> Monoid.Unit.t t
val nothing : Monoid.Unit.t -> Monoid.Unit.t t
val non : ('a -> bool t) -> 'a -> bool t
val apply_n_times :
n:Monoid.Int.t -> ('a -> 'a t) -> 'a -> 'a t
val compose :
('b -> 'c t) -> ('a -> 'b t) -> 'a -> 'c t
end
module Pair :
sig
val fst : ('a * 'b) t -> 'a t
val snd : ('a * 'b) t -> 'b t
end
module Triple :
sig
val fst : ('a * 'b * 'c) t -> 'a t
val snd : ('a * 'b * 'c) t -> 'b t
val trd : ('a * 'b * 'c) t -> 'c t
end
module Lift :
sig
val nullary : 'a -> 'a t
val unary : ('a -> 'b) -> 'a t -> 'b t
val binary : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ternary :
('a -> 'b -> 'c -> 'd) ->
'a t -> 'b t -> 'c t -> 'd t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
f:(Monoid.Unit.t -> 'a t) ->
catch:(exn -> 'a t) -> 'a t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a t t -> 'a t t
val all_ignore : 'a t t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
val map : 'a t -> f:('a -> 'b t) -> 'b t t
val iter :
'a t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a t -> f:('a -> bool t) -> bool t
val for_all : 'a t -> f:('a -> bool t) -> bool t
val count :
'a t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> 'a t) -> 'a t
val find :
'a t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a t -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter : 'a t -> f:('a -> bool t) -> 'a t t
val filter_map :
'a t -> f:('a -> 'b Option.t t) -> 'b t t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a T.t -> f:('a -> bool t) -> bool t
val for_all :
'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a T.t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t -> f:('a -> 'b Option.t t) -> 'b T.t t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a T.t -> f:('a -> bool t) -> bool t
val for_all :
'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a T.t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t -> f:('a -> 'b Option.t t) -> 'b T.t t
end
end
module List :
sig
val all : 'a t List.t -> 'a List.t t
val all_ignore : 'a t List.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t List.t -> Monoid.Unit.t t
val map : 'a List.t -> f:('a -> 'b t) -> 'b List.t t
val iter :
'a List.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a List.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a List.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a List.t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a List.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a List.t -> f:('a -> bool t) -> bool t
val for_all : 'a List.t -> f:('a -> bool t) -> bool t
val count :
'a List.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b List.t -> f:('b -> 'a t) -> 'a t
val find :
'a List.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a List.t -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a List.t -> f:('a -> bool t) -> 'a List.t t
val filter_map :
'a List.t -> f:('a -> 'b Option.t t) -> 'b List.t t
end
module Seq :
sig
val all : 'a t Seq.t -> 'a Seq.t t
val all_ignore : 'a t Seq.t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t Seq.t -> Monoid.Unit.t t
val map : 'a Seq.t -> f:('a -> 'b t) -> 'b Seq.t t
val iter :
'a Seq.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a Seq.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a Seq.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a Seq.t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a Seq.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a Seq.t -> f:('a -> bool t) -> bool t
val for_all : 'a Seq.t -> f:('a -> bool t) -> bool t
val count :
'a Seq.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Seq.t -> f:('b -> 'a t) -> 'a t
val find :
'a Seq.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a Seq.t -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter : 'a Seq.t -> f:('a -> bool t) -> 'a Seq.t t
val filter_map :
'a Seq.t -> f:('a -> 'b Option.t t) -> 'b Seq.t t
end
val ( >=> ) : ('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Monad_infix :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
end
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val return : 'a -> 'a t
val map : 'a t -> f:('a -> 'b) -> 'b t
val join : 'a t t -> 'a t
val ignore_m : 'a t -> Monoid.Unit.t t
val all : 'a t list -> 'a list t
val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
module Let_syntax :
sig
val return : 'a -> 'a t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Let_syntax :
sig
val return : 'a -> 'a t
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val map : 'a t -> f:('a -> 'b) -> 'b t
val both : 'a t -> 'b t -> ('a * 'b) t
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
val ( >=> ) :
('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
end
module type S2 =
sig
type ('a, 'e) t
type ('a, 'e) m
type ('a, 'e) e
val lift : ('a, 'e) m -> ('a, 'e) t
val run : ('a, 'e) t -> ('a, 'e) e
val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
val forever : ('a, 'e) t -> ('b, 'e) t
module Fn :
sig
val id : 'a -> ('a, 'e) t
val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
val non : ('a -> (bool, 'e) t) -> 'a -> (bool, 'e) t
val apply_n_times :
n:Monoid.Int.t ->
('a -> ('a, 'e) t) -> 'a -> ('a, 'e) t
val compose :
('b -> ('c, 'e) t) ->
('a -> ('b, 'e) t) -> 'a -> ('c, 'e) t
end
module Pair :
sig
val fst : ('a * 'b, 'e) t -> ('a, 'e) t
val snd : ('a * 'b, 'e) t -> ('b, 'e) t
end
module Triple :
sig
val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
end
module Lift :
sig
val nullary : 'a -> ('a, 'e) t
val unary : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val binary :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ternary :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
f:(Monoid.Unit.t -> ('a, 's) t) ->
catch:(exn -> ('a, 's) t) -> ('a, 's) t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : ('a, 'e) t t -> ('a t, 'e) t
val all_ignore :
('a, 'e) t t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
val map :
'a t -> f:('a -> ('b, 'e) t) -> ('b t, 'e) t
val iter :
'a t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a t -> f:('a -> (bool, 'e) t) -> ('a t, 'e) t
val filter_map :
'a t ->
f:('a -> ('b Option.t, 'e) t) -> ('b t, 'e) t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : ('a, 'e) t T.t -> ('a T.t, 'e) t
val all_ignore :
('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t T.t ->
(Monoid.Unit.t, 'e) t
val map :
'a T.t ->
f:('a -> ('b, 'e) t) -> ('b T.t, 'e) t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) t) ->
('a Option.t, 'e) t
val exists :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a T.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a T.t, 'e) t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b T.t, 'e) t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : ('a, 'e) t T.t -> ('a T.t, 'e) t
val all_ignore :
('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t T.t ->
(Monoid.Unit.t, 'e) t
val map :
'a T.t ->
f:('a -> ('b, 'e) t) -> ('b T.t, 'e) t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) t) ->
('a Option.t, 'e) t
val exists :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a T.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a T.t, 'e) t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b T.t, 'e) t
end
end
module List :
sig
val all : ('a, 'e) t List.t -> ('a List.t, 'e) t
val all_ignore :
('a, 'e) t List.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
val map :
'a List.t ->
f:('a -> ('b, 'e) t) -> ('b List.t, 'e) t
val iter :
'a List.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a List.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a List.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a List.t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a List.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a List.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a List.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a List.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b List.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a List.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a List.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b Option.t, 'e) t
val filter :
'a List.t ->
f:('a -> (bool, 'e) t) -> ('a List.t, 'e) t
val filter_map :
'a List.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b List.t, 'e) t
end
module Seq :
sig
val all : ('a, 'e) t Seq.t -> ('a Seq.t, 'e) t
val all_ignore :
('a, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
val map :
'a Seq.t -> f:('a -> ('b, 'e) t) -> ('b Seq.t, 'e) t
val iter :
'a Seq.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a Seq.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a Seq.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a Seq.t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a Seq.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a Seq.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a Seq.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a Seq.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Seq.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a Seq.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a Seq.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b Option.t, 'e) t
val filter :
'a Seq.t ->
f:('a -> (bool, 'e) t) -> ('a Seq.t, 'e) t
val filter_map :
'a Seq.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b Seq.t, 'e) t
end
val ( >=> ) :
('a -> ('b, 'e) t) ->
('b -> ('c, 'e) t) -> 'a -> ('c, 'e) t
val ( !! ) : 'a -> ('a, 'e) t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val bind :
('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val both :
('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
end
val bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val return : 'a -> ('a, 'b) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore :
(Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
module Syntax :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
val ( >=> ) :
('a -> ('b, 'e) t) ->
('b -> ('c, 'e) t) -> 'a -> ('c, 'e) t
val ( !! ) : 'a -> ('a, 'e) t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
end
end
type 'a t = 'a Core_kernel.Std.Lazy.t
type 'a m = 'a
type 'a e = 'a
val lift : 'a -> 'a t
val run : 'a t -> 'a
val void : 'a t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
val forever : 'a t -> 'b t
module Fn :
sig
val id : 'a -> 'a t
val ignore : 'a t -> Monoid.Unit.t t
val nothing : Monoid.Unit.t -> Monoid.Unit.t t
val non : ('a -> bool t) -> 'a -> bool t
val apply_n_times :
n:Monoid.Int.t -> ('a -> 'a t) -> 'a -> 'a t
val compose : ('b -> 'c t) -> ('a -> 'b t) -> 'a -> 'c t
end
module Pair :
sig
val fst : ('a * 'b) t -> 'a t
val snd : ('a * 'b) t -> 'b t
end
module Triple :
sig
val fst : ('a * 'b * 'c) t -> 'a t
val snd : ('a * 'b * 'c) t -> 'b t
val trd : ('a * 'b * 'c) t -> 'c t
end
module Lift :
sig
val nullary : 'a -> 'a t
val unary : ('a -> 'b) -> 'a t -> 'b t
val binary : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ternary :
('a -> 'b -> 'c -> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
f:(Monoid.Unit.t -> 'a t) -> catch:(exn -> 'a t) -> 'a t
end
module Collection :
sig
module type S =
sig
type 'a t
val all :
'a Core_kernel.Std.Lazy.t t ->
'a t Core_kernel.Std.Lazy.t
val all_ignore :
'a Core_kernel.Std.Lazy.t t ->
Monoid.Unit.t Core_kernel.Std.Lazy.t
val sequence :
Monoid.Unit.t Core_kernel.Std.Lazy.t t ->
Monoid.Unit.t Core_kernel.Std.Lazy.t
val map :
'a t ->
f:('a -> 'b Core_kernel.Std.Lazy.t) ->
'b t Core_kernel.Std.Lazy.t
val iter :
'a t ->
f:('a -> Monoid.Unit.t Core_kernel.Std.Lazy.t) ->
Monoid.Unit.t Core_kernel.Std.Lazy.t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> 'b Core_kernel.Std.Lazy.t) ->
'b Core_kernel.Std.Lazy.t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> 'b Core_kernel.Std.Lazy.t) ->
'b Core_kernel.Std.Lazy.t
val fold_right :
'a t ->
f:('a -> 'b -> 'b Core_kernel.Std.Lazy.t) ->
init:'b -> 'b Core_kernel.Std.Lazy.t
val reduce :
'a t ->
f:('a -> 'a -> 'a Core_kernel.Std.Lazy.t) ->
'a Option.t Core_kernel.Std.Lazy.t
val exists :
'a t ->
f:('a -> bool Core_kernel.Std.Lazy.t) ->
bool Core_kernel.Std.Lazy.t
val for_all :
'a t ->
f:('a -> bool Core_kernel.Std.Lazy.t) ->
bool Core_kernel.Std.Lazy.t
val count :
'a t ->
f:('a -> bool Core_kernel.Std.Lazy.t) ->
Monoid.Int.t Core_kernel.Std.Lazy.t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t ->
f:('b -> 'a Core_kernel.Std.Lazy.t) ->
'a Core_kernel.Std.Lazy.t
val find :
'a t ->
f:('a -> bool Core_kernel.Std.Lazy.t) ->
'a Option.t Core_kernel.Std.Lazy.t
val find_map :
'a t ->
f:('a -> 'b Option.t Core_kernel.Std.Lazy.t) ->
'b Option.t Core_kernel.Std.Lazy.t
val filter :
'a t ->
f:('a -> bool Core_kernel.Std.Lazy.t) ->
'a t Core_kernel.Std.Lazy.t
val filter_map :
'a t ->
f:('a -> 'b Option.t Core_kernel.Std.Lazy.t) ->
'b t Core_kernel.Std.Lazy.t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a T.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a T.t -> f:('a -> bool t) -> bool t
val for_all : 'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a T.t -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter : 'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t -> f:('a -> 'b Option.t t) -> 'b T.t t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a T.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a T.t -> f:('a -> bool t) -> bool t
val for_all : 'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a T.t -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter : 'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t -> f:('a -> 'b Option.t t) -> 'b T.t t
end
end
module List :
sig
val all : 'a t List.t -> 'a List.t t
val all_ignore : 'a t List.t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
val map : 'a List.t -> f:('a -> 'b t) -> 'b List.t t
val iter :
'a List.t -> f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a List.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a List.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a List.t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a List.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a List.t -> f:('a -> bool t) -> bool t
val for_all : 'a List.t -> f:('a -> bool t) -> bool t
val count : 'a List.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b List.t -> f:('b -> 'a t) -> 'a t
val find : 'a List.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a List.t -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter : 'a List.t -> f:('a -> bool t) -> 'a List.t t
val filter_map :
'a List.t -> f:('a -> 'b Option.t t) -> 'b List.t t
end
module Seq :
sig
val all : 'a t Seq.t -> 'a Seq.t t
val all_ignore : 'a t Seq.t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t Seq.t -> Monoid.Unit.t t
val map : 'a Seq.t -> f:('a -> 'b t) -> 'b Seq.t t
val iter :
'a Seq.t -> f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a Seq.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a Seq.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a Seq.t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a Seq.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a Seq.t -> f:('a -> bool t) -> bool t
val for_all : 'a Seq.t -> f:('a -> bool t) -> bool t
val count : 'a Seq.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Seq.t -> f:('b -> 'a t) -> 'a t
val find : 'a Seq.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a Seq.t -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter : 'a Seq.t -> f:('a -> bool t) -> 'a Seq.t t
val filter_map :
'a Seq.t -> f:('a -> 'b Option.t t) -> 'b Seq.t t
end
val ( >=> ) : ('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Monad_infix :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
end
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val return : 'a -> 'a t
val map : 'a t -> f:('a -> 'b) -> 'b t
val join : 'a t t -> 'a t
val ignore_m : 'a t -> Monoid.Unit.t t
val all : 'a t list -> 'a list t
val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
module Let_syntax :
sig
val return : 'a -> 'a t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Let_syntax :
sig
val return : 'a -> 'a t
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val map : 'a t -> f:('a -> 'b) -> 'b t
val both : 'a t -> 'b t -> ('a * 'b) t
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
val ( >=> ) : ('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
module T1 :
functor (M : Monad) ->
sig
type 'a m = 'a M.t
type 'a t =
'a Monads.Std.Monad.Lazy.T1.m Core_kernel.Std.Lazy.t
type 'a e = 'a Monads.Std.Monad.Lazy.T1.m
end
module Make :
functor (M : Monad) ->
sig
val lift : 'a M.t -> 'a T1(M).t
val run : 'a T1(M).t -> 'a Monads.Std.Monad.Lazy.T1.m
val void : 'a T1(M).t -> Monoid.Unit.t T1(M).t
val sequence :
Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
val forever : 'a T1(M).t -> 'b T1(M).t
module Fn :
sig
val id : 'a -> 'a T1(M).t
val ignore : 'a T1(M).t -> Monoid.Unit.t T1(M).t
val nothing : Monoid.Unit.t -> Monoid.Unit.t T1(M).t
val non : ('a -> bool T1(M).t) -> 'a -> bool T1(M).t
val apply_n_times :
n:Monoid.Int.t ->
('a -> 'a T1(M).t) -> 'a -> 'a T1(M).t
val compose :
('b -> 'c T1(M).t) ->
('a -> 'b T1(M).t) -> 'a -> 'c T1(M).t
end
module Pair :
sig
val fst : ('a * 'b) T1(M).t -> 'a T1(M).t
val snd : ('a * 'b) T1(M).t -> 'b T1(M).t
end
module Triple :
sig
val fst : ('a * 'b * 'c) T1(M).t -> 'a T1(M).t
val snd : ('a * 'b * 'c) T1(M).t -> 'b T1(M).t
val trd : ('a * 'b * 'c) T1(M).t -> 'c T1(M).t
end
module Lift :
sig
val nullary : 'a -> 'a T1(M).t
val unary : ('a -> 'b) -> 'a T1(M).t -> 'b T1(M).t
val binary :
('a -> 'b -> 'c) ->
'a T1(M).t -> 'b T1(M).t -> 'c T1(M).t
val ternary :
('a -> 'b -> 'c -> 'd) ->
'a T1(M).t ->
'b T1(M).t -> 'c T1(M).t -> 'd T1(M).t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(M).t ->
'b T1(M).t ->
'c T1(M).t -> 'd T1(M).t -> 'e T1(M).t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(M).t ->
'b T1(M).t ->
'c T1(M).t ->
'd T1(M).t -> 'e T1(M).t -> 'f T1(M).t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t T1(M).t) ->
f:(Monoid.Unit.t -> 'a T1(M).t) ->
catch:(exn -> 'a T1(M).t) -> 'a T1(M).t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a T1(M).t t -> 'a t T1(M).t
val all_ignore :
'a T1(M).t t -> Monoid.Unit.t T1(M).t
val sequence :
Monoid.Unit.t T1(M).t t ->
Monoid.Unit.t T1(M).t
val map :
'a t -> f:('a -> 'b T1(M).t) -> 'b t T1(M).t
val iter :
'a t ->
f:('a -> Monoid.Unit.t T1(M).t) ->
Monoid.Unit.t T1(M).t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_right :
'a t ->
f:('a -> 'b -> 'b T1(M).t) ->
init:'b -> 'b T1(M).t
val reduce :
'a t ->
f:('a -> 'a -> 'a T1(M).t) ->
'a Option.t T1(M).t
val exists :
'a t -> f:('a -> bool T1(M).t) -> bool T1(M).t
val for_all :
'a t -> f:('a -> bool T1(M).t) -> bool T1(M).t
val count :
'a t ->
f:('a -> bool T1(M).t) -> Monoid.Int.t T1(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> 'a T1(M).t) -> 'a T1(M).t
val find :
'a t ->
f:('a -> bool T1(M).t) -> 'a Option.t T1(M).t
val find_map :
'a t ->
f:('a -> 'b Option.t T1(M).t) ->
'b Option.t T1(M).t
val filter :
'a t -> f:('a -> bool T1(M).t) -> 'a t T1(M).t
val filter_map :
'a t ->
f:('a -> 'b Option.t T1(M).t) -> 'b t T1(M).t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : 'a T1(M).t T.t -> 'a T.t T1(M).t
val all_ignore :
'a T1(M).t T.t -> Monoid.Unit.t T1(M).t
val sequence :
Monoid.Unit.t T1(M).t T.t ->
Monoid.Unit.t T1(M).t
val map :
'a T.t ->
f:('a -> 'b T1(M).t) -> 'b T.t T1(M).t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t T1(M).t) ->
Monoid.Unit.t T1(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b T1(M).t) ->
init:'b -> 'b T1(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> 'a T1(M).t) ->
'a Option.t T1(M).t
val exists :
'a T.t ->
f:('a -> bool T1(M).t) -> bool T1(M).t
val for_all :
'a T.t ->
f:('a -> bool T1(M).t) -> bool T1(M).t
val count :
'a T.t ->
f:('a -> bool T1(M).t) ->
Monoid.Int.t T1(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a T1(M).t) -> 'a T1(M).t
val find :
'a T.t ->
f:('a -> bool T1(M).t) -> 'a Option.t T1(M).t
val find_map :
'a T.t ->
f:('a -> 'b Option.t T1(M).t) ->
'b Option.t T1(M).t
val filter :
'a T.t ->
f:('a -> bool T1(M).t) -> 'a T.t T1(M).t
val filter_map :
'a T.t ->
f:('a -> 'b Option.t T1(M).t) ->
'b T.t T1(M).t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : 'a T1(M).t T.t -> 'a T.t T1(M).t
val all_ignore :
'a T1(M).t T.t -> Monoid.Unit.t T1(M).t
val sequence :
Monoid.Unit.t T1(M).t T.t ->
Monoid.Unit.t T1(M).t
val map :
'a T.t ->
f:('a -> 'b T1(M).t) -> 'b T.t T1(M).t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t T1(M).t) ->
Monoid.Unit.t T1(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b T1(M).t) ->
init:'b -> 'b T1(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> 'a T1(M).t) ->
'a Option.t T1(M).t
val exists :
'a T.t ->
f:('a -> bool T1(M).t) -> bool T1(M).t
val for_all :
'a T.t ->
f:('a -> bool T1(M).t) -> bool T1(M).t
val count :
'a T.t ->
f:('a -> bool T1(M).t) ->
Monoid.Int.t T1(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a T1(M).t) -> 'a T1(M).t
val find :
'a T.t ->
f:('a -> bool T1(M).t) -> 'a Option.t T1(M).t
val find_map :
'a T.t ->
f:('a -> 'b Option.t T1(M).t) ->
'b Option.t T1(M).t
val filter :
'a T.t ->
f:('a -> bool T1(M).t) -> 'a T.t T1(M).t
val filter_map :
'a T.t ->
f:('a -> 'b Option.t T1(M).t) ->
'b T.t T1(M).t
end
end
module List :
sig
val all : 'a T1(M).t list -> 'a list T1(M).t
val all_ignore :
'a T1(M).t list -> Monoid.Unit.t T1(M).t
val sequence :
Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
val map :
'a list -> f:('a -> 'b T1(M).t) -> 'b list T1(M).t
val iter :
'a list ->
f:('a -> Monoid.Unit.t T1(M).t) ->
Monoid.Unit.t T1(M).t
val fold :
'a list ->
init:'b -> f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_left :
'a list ->
init:'b -> f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_right :
'a list ->
f:('a -> 'b -> 'b T1(M).t) -> init:'b -> 'b T1(M).t
val reduce :
'a list ->
f:('a -> 'a -> 'a T1(M).t) -> 'a Option.t T1(M).t
val exists :
'a list -> f:('a -> bool T1(M).t) -> bool T1(M).t
val for_all :
'a list -> f:('a -> bool T1(M).t) -> bool T1(M).t
val count :
'a list ->
f:('a -> bool T1(M).t) -> Monoid.Int.t T1(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list -> f:('b -> 'a T1(M).t) -> 'a T1(M).t
val find :
'a list ->
f:('a -> bool T1(M).t) -> 'a Option.t T1(M).t
val find_map :
'a list ->
f:('a -> 'b Option.t T1(M).t) ->
'b Option.t T1(M).t
val filter :
'a list ->
f:('a -> bool T1(M).t) -> 'a list T1(M).t
val filter_map :
'a list ->
f:('a -> 'b Option.t T1(M).t) -> 'b list T1(M).t
end
module Seq :
sig
val all :
'a T1(M).t Core_kernel.Std.Sequence.t ->
'a Core_kernel.Std.Sequence.t T1(M).t
val all_ignore :
'a T1(M).t Core_kernel.Std.Sequence.t ->
Monoid.Unit.t T1(M).t
val sequence :
Monoid.Unit.t T1(M).t Core_kernel.Std.Sequence.t ->
Monoid.Unit.t T1(M).t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b T1(M).t) ->
'b Core_kernel.Std.Sequence.t T1(M).t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> Monoid.Unit.t T1(M).t) ->
Monoid.Unit.t T1(M).t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b -> f:('b -> 'a -> 'b T1(M).t) -> 'b T1(M).t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> 'b T1(M).t) -> init:'b -> 'b T1(M).t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> 'a T1(M).t) -> 'a Option.t T1(M).t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(M).t) -> bool T1(M).t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(M).t) -> bool T1(M).t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(M).t) -> Monoid.Int.t T1(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> 'a T1(M).t) -> 'a T1(M).t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(M).t) -> 'a Option.t T1(M).t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b Option.t T1(M).t) ->
'b Option.t T1(M).t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(M).t) ->
'a Core_kernel.Std.Sequence.t T1(M).t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b Option.t T1(M).t) ->
'b Core_kernel.Std.Sequence.t T1(M).t
end
val ( >=> ) :
('a -> 'b T1(M).t) ->
('b -> 'c T1(M).t) -> 'a -> 'c T1(M).t
val ( !! ) : 'a -> 'a T1(M).t
val ( !$ ) : ('a -> 'b) -> 'a T1(M).t -> 'b T1(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
'a T1(M).t -> 'b T1(M).t -> 'c T1(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a T1(M).t -> 'b T1(M).t -> 'c T1(M).t -> 'd T1(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(M).t ->
'b T1(M).t -> 'c T1(M).t -> 'd T1(M).t -> 'e T1(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(M).t ->
'b T1(M).t ->
'c T1(M).t -> 'd T1(M).t -> 'e T1(M).t -> 'f T1(M).t
val ( >>= ) :
'a T1(M).t -> ('a -> 'b T1(M).t) -> 'b T1(M).t
val ( >>| ) : 'a T1(M).t -> ('a -> 'b) -> 'b T1(M).t
module Monad_infix :
sig
val ( >>= ) :
'a T1(M).t -> ('a -> 'b T1(M).t) -> 'b T1(M).t
val ( >>| ) : 'a T1(M).t -> ('a -> 'b) -> 'b T1(M).t
end
val bind :
'a T1(M).t -> f:('a -> 'b T1(M).t) -> 'b T1(M).t
val return : 'a -> 'a T1(M).t
val map : 'a T1(M).t -> f:('a -> 'b) -> 'b T1(M).t
val join : 'a T1(M).t T1(M).t -> 'a T1(M).t
val ignore_m : 'a T1(M).t -> Monoid.Unit.t T1(M).t
val all : 'a T1(M).t list -> 'a list T1(M).t
val all_ignore :
Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
module Let_syntax :
sig
val return : 'a -> 'a T1(M).t
val ( >>= ) :
'a T1(M).t -> ('a -> 'b T1(M).t) -> 'b T1(M).t
val ( >>| ) : 'a T1(M).t -> ('a -> 'b) -> 'b T1(M).t
module Let_syntax :
sig
val return : 'a -> 'a T1(M).t
val bind :
'a T1(M).t ->
f:('a -> 'b T1(M).t) -> 'b T1(M).t
val map :
'a T1(M).t -> f:('a -> 'b) -> 'b T1(M).t
val both :
'a T1(M).t -> 'b T1(M).t -> ('a * 'b) T1(M).t
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) :
'a T1(M).t -> ('a -> 'b T1(M).t) -> 'b T1(M).t
val ( >>| ) : 'a T1(M).t -> ('a -> 'b) -> 'b T1(M).t
val ( >=> ) :
('a -> 'b T1(M).t) ->
('b -> 'c T1(M).t) -> 'a -> 'c T1(M).t
val ( !! ) : 'a -> 'a T1(M).t
val ( !$ ) : ('a -> 'b) -> 'a T1(M).t -> 'b T1(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
'a T1(M).t -> 'b T1(M).t -> 'c T1(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a T1(M).t ->
'b T1(M).t -> 'c T1(M).t -> 'd T1(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(M).t ->
'b T1(M).t ->
'c T1(M).t -> 'd T1(M).t -> 'e T1(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(M).t ->
'b T1(M).t ->
'c T1(M).t ->
'd T1(M).t -> 'e T1(M).t -> 'f T1(M).t
end
end
module T2 :
functor (M : Monad2) ->
sig
type ('a, 'e) m = ('a, 'e) M.t
type ('a, 'e) t =
('a, 'e) Monads.Std.Monad.Lazy.T2.m
Core_kernel.Std.Lazy.t
type ('a, 'e) e = ('a, 'e) Monads.Std.Monad.Lazy.T2.m
end
module Make2 :
functor (M : Monad2) ->
sig
val lift : ('a, 'e) M.t -> ('a, 'e) T2(M).t
val run :
('a, 'e) T2(M).t -> ('a, 'e) Monads.Std.Monad.Lazy.T2.m
val void :
('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
module Fn :
sig
val id : 'a -> ('a, 'e) T2(M).t
val ignore :
('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
val nothing :
Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
val non :
('a -> (bool, 'e) T2(M).t) ->
'a -> (bool, 'e) T2(M).t
val apply_n_times :
n:Monoid.Int.t ->
('a -> ('a, 'e) T2(M).t) -> 'a -> ('a, 'e) T2(M).t
val compose :
('b -> ('c, 'e) T2(M).t) ->
('a -> ('b, 'e) T2(M).t) -> 'a -> ('c, 'e) T2(M).t
end
module Pair :
sig
val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
end
module Triple :
sig
val fst :
('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
val snd :
('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
val trd :
('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
end
module Lift :
sig
val nullary : 'a -> ('a, 'e) T2(M).t
val unary :
('a -> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
val binary :
('a -> 'b -> 'c) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
val ternary :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t ->
('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t -> ('e, 's) T2(M).t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t ->
('e, 's) T2(M).t -> ('f, 's) T2(M).t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t ->
(Monoid.Unit.t, 's) T2(M).t) ->
f:(Monoid.Unit.t -> ('a, 's) T2(M).t) ->
catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
end
module Collection :
sig
module type S =
sig
type 'a t
val all :
('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b t, 'e) T2(M).t
val iter :
'a t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val for_all :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val count :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t ->
f:('b -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
val find :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a t, 'e) T2(M).t
val filter_map :
'a t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b t, 'e) T2(M).t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all :
('a, 'e) T2(M).t T.t -> ('a T.t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a T.t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val count :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> ('a, 'e) T2(M).t) ->
('a, 'e) T2(M).t
val find :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a T.t, 'e) T2(M).t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all :
('a, 'e) T2(M).t T.t -> ('a T.t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a T.t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val count :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> ('a, 'e) T2(M).t) ->
('a, 'e) T2(M).t
val find :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a T.t, 'e) T2(M).t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
end
end
module List :
sig
val all :
('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a list ->
f:('a -> ('b, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
val iter :
'a list ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a list ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a list ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a list ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a list ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a list ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val for_all :
'a list ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val count :
'a list ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list ->
f:('b -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
val find :
'a list ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a list ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a list ->
f:('a -> (bool, 'e) T2(M).t) ->
('a list, 'e) T2(M).t
val filter_map :
'a list ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b list, 'e) T2(M).t
end
module Seq :
sig
val all :
('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
('a Core_kernel.Std.Sequence.t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t
Core_kernel.Std.Sequence.t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b Core_kernel.Std.Sequence.t, 'e) T2(M).t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Core_kernel.Std.Sequence.t, 'e) T2(M).t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Core_kernel.Std.Sequence.t, 'e) T2(M).t
end
val ( >=> ) :
('a -> ('b, 'e) T2(M).t) ->
('b -> ('c, 'e) T2(M).t) -> 'a -> ('c, 'e) T2(M).t
val ( !! ) : 'a -> ('a, 'e) T2(M).t
val ( !$ ) :
('a -> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t ->
('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t -> ('e, 's) T2(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t ->
('e, 's) T2(M).t -> ('f, 's) T2(M).t
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) T2(M).t
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) T2(M).t
val bind :
('a, 'e) T2(M).t ->
f:('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val map :
('a, 'e) T2(M).t ->
f:('a -> 'b) -> ('b, 'e) T2(M).t
val both :
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
end
val bind :
('a, 'e) T2(M).t ->
f:('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val return : 'a -> ('a, 'b) T2(M).t
val map :
('a, 'e) T2(M).t -> f:('a -> 'b) -> ('b, 'e) T2(M).t
val join :
(('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
val ignore_m :
('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
val all_ignore :
(Monoid.Unit.t, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
module Syntax :
sig
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
val ( >=> ) :
('a -> ('b, 'e) T2(M).t) ->
('b -> ('c, 'e) T2(M).t) -> 'a -> ('c, 'e) T2(M).t
val ( !! ) : 'a -> ('a, 'e) T2(M).t
val ( !$ ) :
('a -> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t ->
('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t -> ('e, 's) T2(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t ->
('e, 's) T2(M).t -> ('f, 's) T2(M).t
end
end
end
module Cont :
sig
module type S =
sig
type 'a t
type 'a m
type 'a e
val lift : 'a m -> 'a t
val run : 'a t -> 'a e
val void : 'a t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
val forever : 'a t -> 'b t
module Fn :
sig
val id : 'a -> 'a t
val ignore : 'a t -> Monoid.Unit.t t
val nothing : Monoid.Unit.t -> Monoid.Unit.t t
val non : ('a -> bool t) -> 'a -> bool t
val apply_n_times :
n:Monoid.Int.t -> ('a -> 'a t) -> 'a -> 'a t
val compose :
('b -> 'c t) -> ('a -> 'b t) -> 'a -> 'c t
end
module Pair :
sig
val fst : ('a * 'b) t -> 'a t
val snd : ('a * 'b) t -> 'b t
end
module Triple :
sig
val fst : ('a * 'b * 'c) t -> 'a t
val snd : ('a * 'b * 'c) t -> 'b t
val trd : ('a * 'b * 'c) t -> 'c t
end
module Lift :
sig
val nullary : 'a -> 'a t
val unary : ('a -> 'b) -> 'a t -> 'b t
val binary : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ternary :
('a -> 'b -> 'c -> 'd) ->
'a t -> 'b t -> 'c t -> 'd t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
f:(Monoid.Unit.t -> 'a t) ->
catch:(exn -> 'a t) -> 'a t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a t t -> 'a t t
val all_ignore : 'a t t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
val map : 'a t -> f:('a -> 'b t) -> 'b t t
val iter :
'a t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a t -> f:('a -> bool t) -> bool t
val for_all : 'a t -> f:('a -> bool t) -> bool t
val count :
'a t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> 'a t) -> 'a t
val find :
'a t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a t -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter : 'a t -> f:('a -> bool t) -> 'a t t
val filter_map :
'a t -> f:('a -> 'b Option.t t) -> 'b t t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a T.t -> f:('a -> bool t) -> bool t
val for_all :
'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a T.t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t -> f:('a -> 'b Option.t t) -> 'b T.t t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : 'a t T.t -> 'a T.t t
val all_ignore : 'a t T.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t T.t -> Monoid.Unit.t t
val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a T.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a T.t -> f:('a -> bool t) -> bool t
val for_all :
'a T.t -> f:('a -> bool t) -> bool t
val count :
'a T.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> 'a t) -> 'a t
val find :
'a T.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a T.t ->
f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a T.t -> f:('a -> bool t) -> 'a T.t t
val filter_map :
'a T.t -> f:('a -> 'b Option.t t) -> 'b T.t t
end
end
module List :
sig
val all : 'a t List.t -> 'a List.t t
val all_ignore : 'a t List.t -> Monoid.Unit.t t
val sequence :
Monoid.Unit.t t List.t -> Monoid.Unit.t t
val map : 'a List.t -> f:('a -> 'b t) -> 'b List.t t
val iter :
'a List.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a List.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a List.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a List.t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a List.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a List.t -> f:('a -> bool t) -> bool t
val for_all : 'a List.t -> f:('a -> bool t) -> bool t
val count :
'a List.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b List.t -> f:('b -> 'a t) -> 'a t
val find :
'a List.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a List.t -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter :
'a List.t -> f:('a -> bool t) -> 'a List.t t
val filter_map :
'a List.t -> f:('a -> 'b Option.t t) -> 'b List.t t
end
module Seq :
sig
val all : 'a t Seq.t -> 'a Seq.t t
val all_ignore : 'a t Seq.t -> Monoid.Unit.t t
val sequence : Monoid.Unit.t t Seq.t -> Monoid.Unit.t t
val map : 'a Seq.t -> f:('a -> 'b t) -> 'b Seq.t t
val iter :
'a Seq.t ->
f:('a -> Monoid.Unit.t t) -> Monoid.Unit.t t
val fold :
'a Seq.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_left :
'a Seq.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t
val fold_right :
'a Seq.t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t
val reduce :
'a Seq.t -> f:('a -> 'a -> 'a t) -> 'a Option.t t
val exists : 'a Seq.t -> f:('a -> bool t) -> bool t
val for_all : 'a Seq.t -> f:('a -> bool t) -> bool t
val count :
'a Seq.t -> f:('a -> bool t) -> Monoid.Int.t t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Seq.t -> f:('b -> 'a t) -> 'a t
val find :
'a Seq.t -> f:('a -> bool t) -> 'a Option.t t
val find_map :
'a Seq.t -> f:('a -> 'b Option.t t) -> 'b Option.t t
val filter : 'a Seq.t -> f:('a -> bool t) -> 'a Seq.t t
val filter_map :
'a Seq.t -> f:('a -> 'b Option.t t) -> 'b Seq.t t
end
val ( >=> ) : ('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Monad_infix :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
end
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val return : 'a -> 'a t
val map : 'a t -> f:('a -> 'b) -> 'b t
val join : 'a t t -> 'a t
val ignore_m : 'a t -> Monoid.Unit.t t
val all : 'a t list -> 'a list t
val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
module Let_syntax :
sig
val return : 'a -> 'a t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Let_syntax :
sig
val return : 'a -> 'a t
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val map : 'a t -> f:('a -> 'b) -> 'b t
val both : 'a t -> 'b t -> ('a * 'b) t
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
val ( >=> ) :
('a -> 'b t) -> ('b -> 'c t) -> 'a -> 'c t
val ( !! ) : 'a -> 'a t
val ( !$ ) : ('a -> 'b) -> 'a t -> 'b t
val ( !$$ ) : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a t -> 'b t -> 'c t -> 'd t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
end
type r
val call : f:(cc:('a -> 'b t) -> 'a t) -> 'a t
end
module type S2 =
sig
type ('a, 'e) t
type 'a m
type ('a, 'e) e
val lift : 'a m -> ('a, 'e) t
val run : ('a, 'e) t -> ('a, 'e) e
val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
val forever : ('a, 'e) t -> ('b, 'e) t
module Fn :
sig
val id : 'a -> ('a, 'e) t
val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
val non : ('a -> (bool, 'e) t) -> 'a -> (bool, 'e) t
val apply_n_times :
n:Monoid.Int.t ->
('a -> ('a, 'e) t) -> 'a -> ('a, 'e) t
val compose :
('b -> ('c, 'e) t) ->
('a -> ('b, 'e) t) -> 'a -> ('c, 'e) t
end
module Pair :
sig
val fst : ('a * 'b, 'e) t -> ('a, 'e) t
val snd : ('a * 'b, 'e) t -> ('b, 'e) t
end
module Triple :
sig
val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
end
module Lift :
sig
val nullary : 'a -> ('a, 'e) t
val unary : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val binary :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ternary :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
f:(Monoid.Unit.t -> ('a, 's) t) ->
catch:(exn -> ('a, 's) t) -> ('a, 's) t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : ('a, 'e) t t -> ('a t, 'e) t
val all_ignore :
('a, 'e) t t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
val map :
'a t -> f:('a -> ('b, 'e) t) -> ('b t, 'e) t
val iter :
'a t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a t -> f:('a -> (bool, 'e) t) -> ('a t, 'e) t
val filter_map :
'a t ->
f:('a -> ('b Option.t, 'e) t) -> ('b t, 'e) t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : ('a, 'e) t T.t -> ('a T.t, 'e) t
val all_ignore :
('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t T.t ->
(Monoid.Unit.t, 'e) t
val map :
'a T.t ->
f:('a -> ('b, 'e) t) -> ('b T.t, 'e) t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) t) ->
('a Option.t, 'e) t
val exists :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a T.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a T.t, 'e) t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b T.t, 'e) t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : ('a, 'e) t T.t -> ('a T.t, 'e) t
val all_ignore :
('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t T.t ->
(Monoid.Unit.t, 'e) t
val map :
'a T.t ->
f:('a -> ('b, 'e) t) -> ('b T.t, 'e) t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) t) ->
init:'b -> ('b, 'e) t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) t) ->
('a Option.t, 'e) t
val exists :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a T.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a T.t, 'e) t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b T.t, 'e) t
end
end
module List :
sig
val all : ('a, 'e) t List.t -> ('a List.t, 'e) t
val all_ignore :
('a, 'e) t List.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
val map :
'a List.t ->
f:('a -> ('b, 'e) t) -> ('b List.t, 'e) t
val iter :
'a List.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a List.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a List.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a List.t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a List.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a List.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a List.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a List.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b List.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a List.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a List.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b Option.t, 'e) t
val filter :
'a List.t ->
f:('a -> (bool, 'e) t) -> ('a List.t, 'e) t
val filter_map :
'a List.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b List.t, 'e) t
end
module Seq :
sig
val all : ('a, 'e) t Seq.t -> ('a Seq.t, 'e) t
val all_ignore :
('a, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
val map :
'a Seq.t -> f:('a -> ('b, 'e) t) -> ('b Seq.t, 'e) t
val iter :
'a Seq.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a Seq.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a Seq.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a Seq.t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a Seq.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a Seq.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a Seq.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a Seq.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Seq.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a Seq.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a Seq.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b Option.t, 'e) t
val filter :
'a Seq.t ->
f:('a -> (bool, 'e) t) -> ('a Seq.t, 'e) t
val filter_map :
'a Seq.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b Seq.t, 'e) t
end
val ( >=> ) :
('a -> ('b, 'e) t) ->
('b -> ('c, 'e) t) -> 'a -> ('c, 'e) t
val ( !! ) : 'a -> ('a, 'e) t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val bind :
('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val both :
('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
end
val bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val return : 'a -> ('a, 'b) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore :
(Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
module Syntax :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
val ( >=> ) :
('a -> ('b, 'e) t) ->
('b -> ('c, 'e) t) -> 'a -> ('c, 'e) t
val ( !! ) : 'a -> ('a, 'e) t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
end
val call :
f:(cc:('a -> ('b, 'e) t) -> ('a, 'e) t) -> ('a, 'e) t
end
type ('a, 'r) cont
type ('a, 'r) t = ('a, 'r) cont
type 'a m = 'a
type ('a, 'e) e = ('a -> 'e) -> 'e
val lift : 'a -> ('a, 'e) t
val run : ('a, 'e) t -> ('a, 'e) e
val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
val forever : ('a, 'e) t -> ('b, 'e) t
module Fn :
sig
val id : 'a -> ('a, 'e) t
val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
val non : ('a -> (bool, 'e) t) -> 'a -> (bool, 'e) t
val apply_n_times :
n:Monoid.Int.t -> ('a -> ('a, 'e) t) -> 'a -> ('a, 'e) t
val compose :
('b -> ('c, 'e) t) ->
('a -> ('b, 'e) t) -> 'a -> ('c, 'e) t
end
module Pair :
sig
val fst : ('a * 'b, 'e) t -> ('a, 'e) t
val snd : ('a * 'b, 'e) t -> ('b, 'e) t
end
module Triple :
sig
val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
end
module Lift :
sig
val nullary : 'a -> ('a, 'e) t
val unary : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val binary :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ternary :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
f:(Monoid.Unit.t -> ('a, 's) t) ->
catch:(exn -> ('a, 's) t) -> ('a, 's) t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : ('a, 'e) cont t -> ('a t, 'e) cont
val all_ignore :
('a, 'e) cont t -> (Monoid.Unit.t, 'e) cont
val sequence :
(Monoid.Unit.t, 'e) cont t ->
(Monoid.Unit.t, 'e) cont
val map :
'a t -> f:('a -> ('b, 'e) cont) -> ('b t, 'e) cont
val iter :
'a t ->
f:('a -> (Monoid.Unit.t, 'e) cont) ->
(Monoid.Unit.t, 'e) cont
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) cont) -> ('b, 'e) cont
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) cont) -> ('b, 'e) cont
val fold_right :
'a t ->
f:('a -> 'b -> ('b, 'e) cont) ->
init:'b -> ('b, 'e) cont
val reduce :
'a t ->
f:('a -> 'a -> ('a, 'e) cont) ->
('a Option.t, 'e) cont
val exists :
'a t -> f:('a -> (bool, 'e) cont) -> (bool, 'e) cont
val for_all :
'a t -> f:('a -> (bool, 'e) cont) -> (bool, 'e) cont
val count :
'a t ->
f:('a -> (bool, 'e) cont) -> (Monoid.Int.t, 'e) cont
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t -> f:('b -> ('a, 'e) cont) -> ('a, 'e) cont
val find :
'a t ->
f:('a -> (bool, 'e) cont) -> ('a Option.t, 'e) cont
val find_map :
'a t ->
f:('a -> ('b Option.t, 'e) cont) ->
('b Option.t, 'e) cont
val filter :
'a t -> f:('a -> (bool, 'e) cont) -> ('a t, 'e) cont
val filter_map :
'a t ->
f:('a -> ('b Option.t, 'e) cont) -> ('b t, 'e) cont
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all : ('a, 'e) t T.t -> ('a T.t, 'e) t
val all_ignore :
('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val map :
'a T.t -> f:('a -> ('b, 'e) t) -> ('b T.t, 'e) t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a T.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a T.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a T.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a T.t -> f:('a -> (bool, 'e) t) -> ('a T.t, 'e) t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b T.t, 'e) t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all : ('a, 'e) t T.t -> ('a T.t, 'e) t
val all_ignore :
('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
val map :
'a T.t -> f:('a -> ('b, 'e) t) -> ('b T.t, 'e) t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) t) ->
(Monoid.Unit.t, 'e) t
val fold :
'a T.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a T.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a T.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a T.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a T.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a T.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) ->
('b Option.t, 'e) t
val filter :
'a T.t -> f:('a -> (bool, 'e) t) -> ('a T.t, 'e) t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b T.t, 'e) t
end
end
module List :
sig
val all : ('a, 'e) t List.t -> ('a List.t, 'e) t
val all_ignore : ('a, 'e) t List.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
val map :
'a List.t -> f:('a -> ('b, 'e) t) -> ('b List.t, 'e) t
val iter :
'a List.t ->
f:('a -> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
val fold :
'a List.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a List.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a List.t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a List.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a List.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a List.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a List.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b List.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a List.t ->
f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a List.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b Option.t, 'e) t
val filter :
'a List.t -> f:('a -> (bool, 'e) t) -> ('a List.t, 'e) t
val filter_map :
'a List.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b List.t, 'e) t
end
module Seq :
sig
val all : ('a, 'e) t Seq.t -> ('a Seq.t, 'e) t
val all_ignore : ('a, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
val sequence :
(Monoid.Unit.t, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
val map :
'a Seq.t -> f:('a -> ('b, 'e) t) -> ('b Seq.t, 'e) t
val iter :
'a Seq.t ->
f:('a -> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
val fold :
'a Seq.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_left :
'a Seq.t ->
init:'b -> f:('b -> 'a -> ('b, 'e) t) -> ('b, 'e) t
val fold_right :
'a Seq.t ->
f:('a -> 'b -> ('b, 'e) t) -> init:'b -> ('b, 'e) t
val reduce :
'a Seq.t ->
f:('a -> 'a -> ('a, 'e) t) -> ('a Option.t, 'e) t
val exists :
'a Seq.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val for_all :
'a Seq.t -> f:('a -> (bool, 'e) t) -> (bool, 'e) t
val count :
'a Seq.t ->
f:('a -> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Seq.t -> f:('b -> ('a, 'e) t) -> ('a, 'e) t
val find :
'a Seq.t -> f:('a -> (bool, 'e) t) -> ('a Option.t, 'e) t
val find_map :
'a Seq.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b Option.t, 'e) t
val filter :
'a Seq.t -> f:('a -> (bool, 'e) t) -> ('a Seq.t, 'e) t
val filter_map :
'a Seq.t ->
f:('a -> ('b Option.t, 'e) t) -> ('b Seq.t, 'e) t
end
val ( >=> ) :
('a -> ('b, 'e) t) -> ('b -> ('c, 'e) t) -> 'a -> ('c, 'e) t
val ( !! ) : 'a -> ('a, 'e) t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val ( !$$ ) :
('a -> 'b -> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
val ( >>= ) : ('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) t
val bind :
('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
end
val bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val return : 'a -> ('a, 'b) t
val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t
val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_ignore :
(Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
module Syntax :
sig
val ( >>= ) :
('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
val ( >=> ) :
('a -> ('b, 'e) t) ->
('b -> ('c, 'e) t) -> 'a -> ('c, 'e) t
val ( !! ) : 'a -> ('a, 'e) t
val ( !$ ) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) t ->
('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) t ->
('b, 's) t ->
('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
end
val call :
f:(cc:('a -> ('b, 'e) t) -> ('a, 'e) t) -> ('a, 'e) t
module T1 :
functor (T : Core_kernel.Std.T) (M : Monad) ->
sig
type r = T.t
type 'a m = 'a M.t
type 'a t =
('a,
Monads.Std.Monad.Cont.T1.r
Monads.Std.Monad.Cont.T1.m)
Monads.Std.Monad.Cont.cont
type 'a e =
('a ->
Monads.Std.Monad.Cont.T1.r
Monads.Std.Monad.Cont.T1.m) ->
Monads.Std.Monad.Cont.T1.r Monads.Std.Monad.Cont.T1.m
end
module T2 :
functor (M : Monad) ->
sig
type 'a m = 'a M.t
type ('a, 'e) t =
('a, 'e Monads.Std.Monad.Cont.T2.m)
Monads.Std.Monad.Cont.cont
type ('a, 'e) e =
('a -> 'e Monads.Std.Monad.Cont.T2.m) ->
'e Monads.Std.Monad.Cont.T2.m
end
module Make :
functor (T : Core_kernel.Std.T) (M : Monad) ->
sig
val lift : 'a M.t -> 'a T1(T)(M).t
val run : 'a T1(T)(M).t -> 'a T1(T)(M).e
val void : 'a T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t list ->
Monoid.Unit.t T1(T)(M).t
val forever : 'a T1(T)(M).t -> 'b T1(T)(M).t
module Fn :
sig
val id : 'a -> 'a T1(T)(M).t
val ignore :
'a T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
val nothing :
Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t
val non :
('a -> bool T1(T)(M).t) -> 'a -> bool T1(T)(M).t
val apply_n_times :
n:Monoid.Int.t ->
('a -> 'a T1(T)(M).t) -> 'a -> 'a T1(T)(M).t
val compose :
('b -> 'c T1(T)(M).t) ->
('a -> 'b T1(T)(M).t) -> 'a -> 'c T1(T)(M).t
end
module Pair :
sig
val fst : ('a * 'b) T1(T)(M).t -> 'a T1(T)(M).t
val snd : ('a * 'b) T1(T)(M).t -> 'b T1(T)(M).t
end
module Triple :
sig
val fst : ('a * 'b * 'c) T1(T)(M).t -> 'a T1(T)(M).t
val snd : ('a * 'b * 'c) T1(T)(M).t -> 'b T1(T)(M).t
val trd : ('a * 'b * 'c) T1(T)(M).t -> 'c T1(T)(M).t
end
module Lift :
sig
val nullary : 'a -> 'a T1(T)(M).t
val unary :
('a -> 'b) -> 'a T1(T)(M).t -> 'b T1(T)(M).t
val binary :
('a -> 'b -> 'c) ->
'a T1(T)(M).t -> 'b T1(T)(M).t -> 'c T1(T)(M).t
val ternary :
('a -> 'b -> 'c -> 'd) ->
'a T1(T)(M).t ->
'b T1(T)(M).t -> 'c T1(T)(M).t -> 'd T1(T)(M).t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t -> 'd T1(T)(M).t -> 'e T1(T)(M).t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t ->
'd T1(T)(M).t -> 'e T1(T)(M).t -> 'f T1(T)(M).t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t) ->
f:(Monoid.Unit.t -> 'a T1(T)(M).t) ->
catch:(exn -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
end
module Collection :
sig
module type S =
sig
type 'a t
val all : 'a T1(T)(M).t t -> 'a t T1(T)(M).t
val all_ignore :
'a T1(T)(M).t t -> Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t t ->
Monoid.Unit.t T1(T)(M).t
val map :
'a t ->
f:('a -> 'b T1(T)(M).t) -> 'b t T1(T)(M).t
val iter :
'a t ->
f:('a -> Monoid.Unit.t T1(T)(M).t) ->
Monoid.Unit.t T1(T)(M).t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_right :
'a t ->
f:('a -> 'b -> 'b T1(T)(M).t) ->
init:'b -> 'b T1(T)(M).t
val reduce :
'a t ->
f:('a -> 'a -> 'a T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val exists :
'a t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val for_all :
'a t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val count :
'a t ->
f:('a -> bool T1(T)(M).t) ->
Monoid.Int.t T1(T)(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t ->
f:('b -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
val find :
'a t ->
f:('a -> bool T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val find_map :
'a t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Option.t T1(T)(M).t
val filter :
'a t ->
f:('a -> bool T1(T)(M).t) -> 'a t T1(T)(M).t
val filter_map :
'a t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b t T1(T)(M).t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all :
'a T1(T)(M).t T.t -> 'a T.t T1(T)(M).t
val all_ignore :
'a T1(T)(M).t T.t -> Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t T.t ->
Monoid.Unit.t T1(T)(M).t
val map :
'a T.t ->
f:('a -> 'b T1(T)(M).t) -> 'b T.t T1(T)(M).t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t T1(T)(M).t) ->
Monoid.Unit.t T1(T)(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) ->
'b T1(T)(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) ->
'b T1(T)(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b T1(T)(M).t) ->
init:'b -> 'b T1(T)(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> 'a T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val exists :
'a T.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val for_all :
'a T.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val count :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
Monoid.Int.t T1(T)(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
val find :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val find_map :
'a T.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Option.t T1(T)(M).t
val filter :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
'a T.t T1(T)(M).t
val filter_map :
'a T.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b T.t T1(T)(M).t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all :
'a T1(T)(M).t T.t -> 'a T.t T1(T)(M).t
val all_ignore :
'a T1(T)(M).t T.t -> Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t T.t ->
Monoid.Unit.t T1(T)(M).t
val map :
'a T.t ->
f:('a -> 'b T1(T)(M).t) -> 'b T.t T1(T)(M).t
val iter :
'a T.t ->
f:('a -> Monoid.Unit.t T1(T)(M).t) ->
Monoid.Unit.t T1(T)(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) ->
'b T1(T)(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) ->
'b T1(T)(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> 'b T1(T)(M).t) ->
init:'b -> 'b T1(T)(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> 'a T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val exists :
'a T.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val for_all :
'a T.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val count :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
Monoid.Int.t T1(T)(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
val find :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val find_map :
'a T.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Option.t T1(T)(M).t
val filter :
'a T.t ->
f:('a -> bool T1(T)(M).t) ->
'a T.t T1(T)(M).t
val filter_map :
'a T.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b T.t T1(T)(M).t
end
end
module List :
sig
val all : 'a T1(T)(M).t list -> 'a list T1(T)(M).t
val all_ignore :
'a T1(T)(M).t list -> Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t list ->
Monoid.Unit.t T1(T)(M).t
val map :
'a list ->
f:('a -> 'b T1(T)(M).t) -> 'b list T1(T)(M).t
val iter :
'a list ->
f:('a -> Monoid.Unit.t T1(T)(M).t) ->
Monoid.Unit.t T1(T)(M).t
val fold :
'a list ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_left :
'a list ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_right :
'a list ->
f:('a -> 'b -> 'b T1(T)(M).t) ->
init:'b -> 'b T1(T)(M).t
val reduce :
'a list ->
f:('a -> 'a -> 'a T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val exists :
'a list ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val for_all :
'a list ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val count :
'a list ->
f:('a -> bool T1(T)(M).t) ->
Monoid.Int.t T1(T)(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list -> f:('b -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
val find :
'a list ->
f:('a -> bool T1(T)(M).t) -> 'a Option.t T1(T)(M).t
val find_map :
'a list ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Option.t T1(T)(M).t
val filter :
'a list ->
f:('a -> bool T1(T)(M).t) -> 'a list T1(T)(M).t
val filter_map :
'a list ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b list T1(T)(M).t
end
module Seq :
sig
val all :
'a T1(T)(M).t Core_kernel.Std.Sequence.t ->
'a Core_kernel.Std.Sequence.t T1(T)(M).t
val all_ignore :
'a T1(T)(M).t Core_kernel.Std.Sequence.t ->
Monoid.Unit.t T1(T)(M).t
val sequence :
Monoid.Unit.t T1(T)(M).t Core_kernel.Std.Sequence.t ->
Monoid.Unit.t T1(T)(M).t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b T1(T)(M).t) ->
'b Core_kernel.Std.Sequence.t T1(T)(M).t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> Monoid.Unit.t T1(T)(M).t) ->
Monoid.Unit.t T1(T)(M).t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b ->
f:('b -> 'a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> 'b T1(T)(M).t) ->
init:'b -> 'b T1(T)(M).t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> 'a T1(T)(M).t) ->
'a Option.t T1(T)(M).t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(T)(M).t) -> bool T1(T)(M).t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(T)(M).t) ->
Monoid.Int.t T1(T)(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> 'a T1(T)(M).t) -> 'a T1(T)(M).t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(T)(M).t) -> 'a Option.t T1(T)(M).t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Option.t T1(T)(M).t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> bool T1(T)(M).t) ->
'a Core_kernel.Std.Sequence.t T1(T)(M).t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b Option.t T1(T)(M).t) ->
'b Core_kernel.Std.Sequence.t T1(T)(M).t
end
val ( >=> ) :
('a -> 'b T1(T)(M).t) ->
('b -> 'c T1(T)(M).t) -> 'a -> 'c T1(T)(M).t
val ( !! ) : 'a -> 'a T1(T)(M).t
val ( !$ ) : ('a -> 'b) -> 'a T1(T)(M).t -> 'b T1(T)(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
'a T1(T)(M).t -> 'b T1(T)(M).t -> 'c T1(T)(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a T1(T)(M).t ->
'b T1(T)(M).t -> 'c T1(T)(M).t -> 'd T1(T)(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t -> 'd T1(T)(M).t -> 'e T1(T)(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t ->
'd T1(T)(M).t -> 'e T1(T)(M).t -> 'f T1(T)(M).t
val ( >>= ) :
'a T1(T)(M).t -> ('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val ( >>| ) :
'a T1(T)(M).t -> ('a -> 'b) -> 'b T1(T)(M).t
module Monad_infix :
sig
val ( >>= ) :
'a T1(T)(M).t ->
('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val ( >>| ) :
'a T1(T)(M).t -> ('a -> 'b) -> 'b T1(T)(M).t
end
val bind :
'a T1(T)(M).t ->
f:('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val return : 'a -> 'a T1(T)(M).t
val map : 'a T1(T)(M).t -> f:('a -> 'b) -> 'b T1(T)(M).t
val join : 'a T1(T)(M).t T1(T)(M).t -> 'a T1(T)(M).t
val ignore_m : 'a T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
val all : 'a T1(T)(M).t list -> 'a list T1(T)(M).t
val all_ignore :
Monoid.Unit.t T1(T)(M).t list ->
Monoid.Unit.t T1(T)(M).t
module Let_syntax :
sig
val return : 'a -> 'a T1(T)(M).t
val ( >>= ) :
'a T1(T)(M).t ->
('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val ( >>| ) :
'a T1(T)(M).t -> ('a -> 'b) -> 'b T1(T)(M).t
module Let_syntax :
sig
val return : 'a -> 'a T1(T)(M).t
val bind :
'a T1(T)(M).t ->
f:('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val map :
'a T1(T)(M).t -> f:('a -> 'b) -> 'b T1(T)(M).t
val both :
'a T1(T)(M).t ->
'b T1(T)(M).t -> ('a * 'b) T1(T)(M).t
module Open_on_rhs : sig end
end
end
module Syntax :
sig
val ( >>= ) :
'a T1(T)(M).t ->
('a -> 'b T1(T)(M).t) -> 'b T1(T)(M).t
val ( >>| ) :
'a T1(T)(M).t -> ('a -> 'b) -> 'b T1(T)(M).t
val ( >=> ) :
('a -> 'b T1(T)(M).t) ->
('b -> 'c T1(T)(M).t) -> 'a -> 'c T1(T)(M).t
val ( !! ) : 'a -> 'a T1(T)(M).t
val ( !$ ) :
('a -> 'b) -> 'a T1(T)(M).t -> 'b T1(T)(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
'a T1(T)(M).t -> 'b T1(T)(M).t -> 'c T1(T)(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
'a T1(T)(M).t ->
'b T1(T)(M).t -> 'c T1(T)(M).t -> 'd T1(T)(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t -> 'd T1(T)(M).t -> 'e T1(T)(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
'a T1(T)(M).t ->
'b T1(T)(M).t ->
'c T1(T)(M).t ->
'd T1(T)(M).t -> 'e T1(T)(M).t -> 'f T1(T)(M).t
end
val call :
f:(cc:('a -> 'b T1(T)(M).t) -> 'a T1(T)(M).t) ->
'a T1(T)(M).t
end
module Make2 :
functor (M : Monad) ->
sig
val lift : 'a M.t -> ('a, 'e) T2(M).t
val run : ('a, 'e) T2(M).t -> ('a, 'e) T2(M).e
val void :
('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
module Fn :
sig
val id : 'a -> ('a, 'e) T2(M).t
val ignore :
('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
val nothing :
Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
val non :
('a -> (bool, 'e) T2(M).t) ->
'a -> (bool, 'e) T2(M).t
val apply_n_times :
n:Monoid.Int.t ->
('a -> ('a, 'e) T2(M).t) -> 'a -> ('a, 'e) T2(M).t
val compose :
('b -> ('c, 'e) T2(M).t) ->
('a -> ('b, 'e) T2(M).t) -> 'a -> ('c, 'e) T2(M).t
end
module Pair :
sig
val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
end
module Triple :
sig
val fst :
('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
val snd :
('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
val trd :
('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
end
module Lift :
sig
val nullary : 'a -> ('a, 'e) T2(M).t
val unary :
('a -> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
val binary :
('a -> 'b -> 'c) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
val ternary :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t ->
('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
val quaternary :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t -> ('e, 's) T2(M).t
val quinary :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t ->
('e, 's) T2(M).t -> ('f, 's) T2(M).t
end
module Exn :
sig
val expect :
?finally:(Monoid.Unit.t ->
(Monoid.Unit.t, 's) T2(M).t) ->
f:(Monoid.Unit.t -> ('a, 's) T2(M).t) ->
catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
end
module Collection :
sig
module type S =
sig
type 'a t
val all :
('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b t, 'e) T2(M).t
val iter :
'a t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val for_all :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val count :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b t ->
f:('b -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
val find :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a t, 'e) T2(M).t
val filter_map :
'a t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b t, 'e) T2(M).t
end
module Eager :
functor (T : Collection.Eager) ->
sig
val all :
('a, 'e) T2(M).t T.t -> ('a T.t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a T.t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val count :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> ('a, 'e) T2(M).t) ->
('a, 'e) T2(M).t
val find :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a T.t, 'e) T2(M).t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
end
module Delay :
functor (T : Collection.Delay) ->
sig
val all :
('a, 'e) T2(M).t T.t -> ('a T.t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t T.t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a T.t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
val iter :
'a T.t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a T.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a T.t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a T.t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val for_all :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(bool, 'e) T2(M).t
val count :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b T.t ->
f:('b -> ('a, 'e) T2(M).t) ->
('a, 'e) T2(M).t
val find :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a T.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a T.t, 'e) T2(M).t
val filter_map :
'a T.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b T.t, 'e) T2(M).t
end
end
module List :
sig
val all :
('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a list ->
f:('a -> ('b, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
val iter :
'a list ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a list ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a list ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a list ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a list ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a list ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val for_all :
'a list ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val count :
'a list ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b list ->
f:('b -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
val find :
'a list ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a list ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a list ->
f:('a -> (bool, 'e) T2(M).t) ->
('a list, 'e) T2(M).t
val filter_map :
'a list ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b list, 'e) T2(M).t
end
module Seq :
sig
val all :
('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
('a Core_kernel.Std.Sequence.t, 'e) T2(M).t
val all_ignore :
('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
(Monoid.Unit.t, 'e) T2(M).t
val sequence :
(Monoid.Unit.t, 'e) T2(M).t
Core_kernel.Std.Sequence.t ->
(Monoid.Unit.t, 'e) T2(M).t
val map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b, 'e) T2(M).t) ->
('b Core_kernel.Std.Sequence.t, 'e) T2(M).t
val iter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (Monoid.Unit.t, 'e) T2(M).t) ->
(Monoid.Unit.t, 'e) T2(M).t
val fold :
'a Core_kernel.Std.Sequence.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_left :
'a Core_kernel.Std.Sequence.t ->
init:'b ->
f:('b -> 'a -> ('b, 'e) T2(M).t) ->
('b, 'e) T2(M).t
val fold_right :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'b -> ('b, 'e) T2(M).t) ->
init:'b -> ('b, 'e) T2(M).t
val reduce :
'a Core_kernel.Std.Sequence.t ->
f:('a -> 'a -> ('a, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val exists :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val for_all :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
val count :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) ->
(Monoid.Int.t, 'e) T2(M).t
val map_reduce :
(module Monoid.S with type t = 'a) ->
'b Core_kernel.Std.Sequence.t ->
f:('b -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
val find :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Option.t, 'e) T2(M).t
val find_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Option.t, 'e) T2(M).t
val filter :
'a Core_kernel.Std.Sequence.t ->
f:('a -> (bool, 'e) T2(M).t) ->
('a Core_kernel.Std.Sequence.t, 'e) T2(M).t
val filter_map :
'a Core_kernel.Std.Sequence.t ->
f:('a -> ('b Option.t, 'e) T2(M).t) ->
('b Core_kernel.Std.Sequence.t, 'e) T2(M).t
end
val ( >=> ) :
('a -> ('b, 'e) T2(M).t) ->
('b -> ('c, 'e) T2(M).t) -> 'a -> ('c, 'e) T2(M).t
val ( !! ) : 'a -> ('a, 'e) T2(M).t
val ( !$ ) :
('a -> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t ->
('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t -> ('e, 's) T2(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t ->
('e, 's) T2(M).t -> ('f, 's) T2(M).t
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) T2(M).t
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
module Let_syntax :
sig
val return : 'a -> ('a, 'b) T2(M).t
val bind :
('a, 'e) T2(M).t ->
f:('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val map :
('a, 'e) T2(M).t ->
f:('a -> 'b) -> ('b, 'e) T2(M).t
val both :
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
module Open_on_rhs : sig end
end
end
module Monad_infix :
sig
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
end
val bind :
('a, 'e) T2(M).t ->
f:('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val return : 'a -> ('a, 'b) T2(M).t
val map :
('a, 'e) T2(M).t -> f:('a -> 'b) -> ('b, 'e) T2(M).t
val join :
(('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
val ignore_m :
('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
val all_ignore :
(Monoid.Unit.t, 'e) T2(M).t list ->
(Monoid.Unit.t, 'e) T2(M).t
module Syntax :
sig
val ( >>= ) :
('a, 'e) T2(M).t ->
('a -> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
val ( >>| ) :
('a, 'e) T2(M).t -> ('a -> 'b) -> ('b, 'e) T2(M).t
val ( >=> ) :
('a -> ('b, 'e) T2(M).t) ->
('b -> ('c, 'e) T2(M).t) -> 'a -> ('c, 'e) T2(M).t
val ( !! ) : 'a -> ('a, 'e) T2(M).t
val ( !$ ) :
('a -> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
val ( !$$ ) :
('a -> 'b -> 'c) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
val ( !$$$ ) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t ->
('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
val ( !$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t -> ('e, 's) T2(M).t
val ( !$$$$$ ) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
('a, 's) T2(M).t ->
('b, 's) T2(M).t ->
('c, 's) T2(M).t ->
('d, 's) T2(M).t ->
('e, 's) T2(M).t -> ('f, 's) T2(M).t
end
val call :
f:(cc:('a -> ('b, 'e) T2(M).t) -> ('a, 'e) T2(M).t) ->
('a, 'e) T2(M).t
end
end
end
end
end